概念
python中数据类型包含：
int(整型)
float(浮点型)
Boolean(布尔型)
复数
String(字符串)
List(列表)
Tuple(元组)
Dictionary(字典)
这篇主要针对基础数据类型(int、float、boolean)进行总结
算数运算
1、整数运算
>>> 2 + 2
4
>>> 4 - 2
2
>>> 2 * 2
4
>>> 2 / 2        # 除法运算总是返回浮点数
1.0
>>> 8 / 5        # Python2.x 版本中为1；3.x版本中为1.6
1.6
>>> 2e304 * 39238172739329            # infinity(无穷大)，当计算值过大时，结果为inf
inf
2、浮点数运算
>>> 3.0 + 3
6.0
>>> 3.0 - 2
1.0
>>> 2.0 * 3
6.0
>>> 4.0 + 3
7.0
>>> 4.0 / 2
2.0
注意：浮点数的运算结果总是返回浮点数
3、混合运算
>>> (45 + 5 - 5*6) / 4
5.5
4、求模运算%
>>> 17 % 3
2
>>> 5 * 3 + 2          # 商 * 除数 + 余数
17
5、次方运算
>>> 5 ** 2              # 5的平方
25
>>> 2 ** 7              # 2的7次方
128
>>> -3 ** 2
-9
>>> (-3) ** 2
9
注意： ** 比 -，+ 运算符优先级更高
6、取整运算
>>> 17 / 3
5.666666666666667
>>> 17 // 3                  # // 运算符返回结果中整数部分
5
7、虚数和复数运算
>>> 2 + 3 + 3j            # 3j 虚数
(5+3j)
>>> 2 + (3 + 2j)
(5+2j)
>>> 5j + 5j
10j
备注：python用j 或 J 后缀来标记复数的虚数部分，如3+5j
Boolean 常量
Boolean 包含两个常量False、True(注意：首字母必须大写，否则报错)
>>> True
True
>>> False
False
>>> True == 1
True
>>> False == 0
True
>>> False < 1
True
>>> true                                                      # 首字母小写报错
Traceback (most recent call last):
File "", line 1, in 
NameError: name 'true' is not defined
数据类型转换
1、字符串数字转为int型数字
>>> String = "1234"
>>> String
'1234'
>>> int(String)
1234
备注：int()函数可以实现将字符串转为int型数字，此处函数仅对数字型的字符有效
>>> int("12", 16)      # 还可以将指定进制，转换字符串数字为对应的进制的数字
18
2、int 型转为字符串类型
>>> str(512)
'512'
3、int 型转浮点型
>>> float(512)
512.0
4、浮点型转int 型
>>> int(88.8)
88
5、浮点型转str 型
>>> str(88.8)
'88.8'
6、获取字符串中文符的ASCII码
>>> ord("A")
65
备注：只能用于包含单个字符的字符串
7、将ASCII码转换为字符
>>> chr(65)
'A'
数据类型验证
type(object) 用于显示object的数据类型
1、整形
>>> type(1)
2、浮点型
>>> type(1.0)
3、Boolean(布尔型)
>>> type(True)
4、复数
>>> type(12j + 1)
5、字符串
>>> type("")
6、集合
>>> type({1,2})
7、列表
>>> type([1,2])
8、元组
>>> type((1,2,3))
9、字典
>>> type({1:"chanper",2:"18"})
10、字节
>>> type(b"")
11、应用举例
>>> obj = 'string'
>>> if type(obj) != type({}):
...     print("type of arg must be 'dict'")
...
type of arg must be 'dict'

if True:
name2=1
print(name2)
输出：1
if False:
name1=1
print(name1)
报错：
NameError: name 'name1' is not defined
总结：只要代码执行，放在内存中，后面代码就可以使用。这一点与其它语言不一样。 在python中，一个作用域的范围是指函数的范围。
l=[1,2,3]
print(l[3])
输出：
IndexError: list index out of range
l=[1,2,3]
print(l[3:80])
输出：
[]
总结：列表取索引的之前，索引值不能超过列表索引的最大值。当列表取切片的时候，则不受这个限制，即切边范围随便取。
join方法
l=['a','b','c']
tag=True
ll=''
for i in l:
if tag:           #注意的一点是，当循环一个可迭代对象时，
i=i           #如果有一个是特殊的，而其它是一样的，可以利用tag标志位。tag标志位一般在if条件判断中，进入这个if子语句，执行完代码，重新给tag赋值。
tag=False     #不管怎么样，感觉好屌的样子，而且效果也很好。
else:             #要经常采用。虽然 .join() 方法也能实现。
i='_'+i
ll+=i
print(ll)
print('_'.join(l))
输出：
a_b_c
a_b_c
l=　[0,1,2,3,4,5,6,7,8,9,10,11]，删除列表中索引值为偶数。
l=[0,1,2,3,4,5,6,7,8,9,10,11]
for i in range(len(l)):
if i %2==0:
del l[i]
print(l)
结果是报错：
IndexError: list assignment index out of range
因为 for i in range(len(l))，实际上是走了第一遍，遇到len(l)值后就确定了，直到for循环遍历到最大值。
随着删除一些元素，会影响到列表长度，从而使得索引取值时，容易出现错误。
方法一：
复制列表l，保存为列表ll。进行操作，比较low。
方法二：
逆向思维。从后往前取索引，删除元素。删掉的索引值越来越小，而且前面可能要删掉的元素的索引值永远是在列表的合法长度以内。666
l=[0,1,2,3,4,5,6,7,8,9,10,11]
for i in range(len(l)-1,-1,-1):
if i %2==0:
del l[i]
print(l)
输出：
[1, 3, 5, 7, 9, 11]
方法三：
直接用列表切片步长，简直6翻了，切片很强大，步长也同样厉害。 ---del l [ ],作为单独一个语句，而不是列表 l 的方法
l=[0,1,2,3,4,5,6,7,8,9,10,11]
del l[::2]
print(l)
输出：
[1, 3, 5, 7, 9, 11]
dic=dict(k1=1,k2=2,k3=3,k4=4,m5=5,m6=6,m7=7)，删除字典dic中含有k的键值对。
如果按照以下的方式写：
dic=dict(k1=1,k2=2,k3=3,k4=4,m5=5,m6=6,m7=7)
for i in dic:
if 'k' in i:
del dic[i]
print(dic)
结果报错：
RuntimeError: dictionary changed size during iteration
所以，不要在循环字典的过程中，修改字典的大小。
如果是修改字典的value值，这是允许的。例如：
dic=dict(k1=1,k2=2,k3=3,k4=4,m5=5,m6=6,m7=7)
for i in dic:
if 'k' in i:
dic[i]=666
print(dic)
输出：
{'k1': 666, 'k2': 666, 'k3': 666, 'k4': 666, 'm5': 5, 'm6': 6, 'm7': 7}
如果想修改字典的大小，只有退而求其次，建立一个空列表，保存需要更好的key值，然后循环这个列表，进行修改value值。这个列表起到了一个中间人的作用。
dic=dict(k1=1,k2=2,k3=3,k4=4,m5=5,m6=6,m7=7)
l=[]
for i in dic:
if 'k' in i:
l.append(i)
for i in l:
del dic[i]
print(dic)
输出：
{'m5': 5, 'm6': 6, 'm7': 7}
补充，可以直接这样做。
dic=dict(k1=1,k2=2,k3=3,k4=4,m5=5,m6=6,m7=7)
for i in list(dic):                             #这里本质上是for循环一个列表哦，与for i in dic，有着本质的区别。后面的实际上还是在迭代字典。这其实是上面方法的简化。
if 'k' in i:
del dic[i]
print(dic)
综上列表和字典的两个例子，如果列表和字典涉及到删除，一定要慎重！
如果想要实现这样一个功能。敏感词以字符串的格式存储在列表中，用户输入一段话，如果没有敏感词，直接输出，如果含有任意一个敏感词，让用户重新输入，直到输入合法为止。
自我分析：刚开始还是有些懵逼的，看了老师讲的代码，也没理清老师的思路，直到自己用笔写在本子上，一点一点分析。试将思路整理如下：
整体肯定是一个循环，虽然输入正确直接打印，相当于while循环走一遍，但这是可以用break实现的，重要的是如果有敏感词要让用户循环输入。、
判定是否有敏感词本身这段代码时非常简单的。
在循环体内，如果输入合法，直接break跳出循环，这里要有一个if 判断。如果输入不合法。这段代码不会执行，从而也不会break跳出循环体，实现了一直让用户输入的功能。
上一条的if的条件怎么设定就是重中之重的，非常关键。无外乎两种情况，输入合法与不合法，这是就会考虑到tag标志位。初始化一个值，如果用户输入内容不合法，加一行代码，改变标志位。 如果用户输入合法，标志位不会发生改变。if判断，就可以实现上面的功能了。
为什么要考虑到标志位，因为如果用户输入正确，直接打印用户输入的东西，而不循环。这段代码必须是在循环的第一等级中。但是由于如果用户输入错误，输入正确才执行的代码则不能执行，所以必须加一个条件判断，涉及到两种情况，所以要用到tag标志位。
l=['苍老师','小泽玛利亚','樱井莉亚']
while True:
tag=True
msg=input('==>')
for i in l:
if i in msg:
tag=False
break
if tag:
print(msg)
break
17.8.24补充：
int，str，bool，list，tuple，dict，set
元素可以增加删除
可变类型：list，dict，set
不可变类型：int，str，bool，tuple
可变类型，如果变量值相同，但是变量名的id是不一样的，这是毫无疑问的。
不可变类型里，如果变量值形同，变量名的id是一致的，但是有一个例外，就是tuple。上代码。
a=tuple([1,2])
b=tuple([1,2])
print(a,id(a),type(a))
print(b,id(b),type(b))
输出：
(1, 2) 2417742172872 
(1, 2) 2417742172808 
得出结论：元组还是比较特殊的，相比其他不可变类型，如果变量值相等，python还是会在内存中开辟两块独立的空间。这与int，str，bool是不同的。

python数据类型分别有整数int / 浮点数float / 布尔值bool / 元组tuple / 列表list / 字典dict，其中数据类型分为两个大类，一种是可变数据类型；一种是不可变数据类型，二者有什么区别呢？python
一.关于内存
在讲解python可变数据类型和不可变数据类型以前须要先普及一下内存相关的简单知识！git
在python编程的时候，代码中的变量实际上都是存储在计算机内存中，固然这里指的内存在计算机中是虚拟的，你看不见摸不着！每个内存都有一个对应的内存地址，讲到这里须要再次介绍一个python内置函数id()，该函数能够用于获取内存地址！获取内存地址方法以下：github
1编程
2微信
3app
4ide
5函数
6spa
if__name__=="__main__":code
a=10
b=20
print("a的数据类型是：{} 地址：{}".format(type(a),id(a)))
print("b的数据类型是：{} 地址：{}".format(type(b),id(b)))
输出结果：
1
2
a的数据类型是：地址：1994744256
b的数据类型是：地址：1994744576
分析下上面代码：定义了局部变量a和b，python会自动给局部变量分配内存，分别用来存放整数10和20，并经过内置函数id()获取内存地址！关于内存这里不作过多介绍，你须要记住的是：每个内存都有一个一个对应的内存地址，分配的内存在程序结束时由系统自动回收!
二.可变数据类型和不可变数据类型
python数据类型分别有整数int / 浮点数float / 布尔值bool / 元组tuple / 列表list / 字典dict，这是python开发中最经常使用的数据类型！
1.可变数据类型和不可变数据类型区别
可变数据类型：当该数据类型对应的变量的值发生了变化时，若是它对应的内存地址不发生改变，那么这个数据类型就是 可变数据类型。
不可变数据类型：当该数据类型对应的变量的值发生了变化时，若是它对应的内存地址发生了改变，那么这个数据类型就是 不可变数据类型。
总结：可变数据类型更改值后，内存地址不发生改变；不可变数据类型更改值后，内存地址发生改变。
2.不可变数据类型
不可变数据类型：数值类型(int、float、bool)、string(字符串)、tuple(元组)
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
# !usr/bin/env python
# -*- coding:utf-8 _*-
"""
@Author:何以解忧
@Blog(我的博客地址): shuopython.com
@WeChat Official Account(微信公众号)：猿说python
@Github:www.github.com
@File:python_variable.py
@Time:2019/10/24 21:25
@Motto:不积跬步无以致千里，不积小流无以成江海，程序人生的精彩须要坚持不懈地积累！
"""
#整形变量
a=10
print("整形变量a修改以前地址：{}".format(id(a)))
a=20
print("整形变量a修改以后地址：{}".format(id(a)))
print("***"*20)
#浮点数变量
a=10.5
print("浮点数变量a修改以前地址：{}".format(id(a)))
a=20.2
print("浮点数变量a修改以后地址：{}".format(id(a)))
print("***"*20)
#字符串变量
a="hello"
print("字符串变量a修改以前地址：{}".format(id(a)))
a="world"
print("字符串变量a修改以后地址：{}".format(id(a)))
print("***"*20)
#布尔值变量
a=False
print("布尔值a修改以前地址：{}".format(id(a)))
a=True
print("布尔值a修改以后地址：{}".format(id(a)))
print("***"*20)
#元组的数据不能修改，不然会报错
输出结果：
1
2
3
4
5
6
7
8
9
10
11
12
整形变量a修改以前地址：1994744256
整形变量a修改以后地址：1994744576
************************************************************
浮点数变量a修改以前地址：2713286559088
浮点数变量a修改以后地址：2713286559136
************************************************************
字符串变量a修改以前地址：2713269294224
字符串变量a修改以后地址：2713269272112
************************************************************
布尔值a修改以前地址：1994252480
布尔值a修改以后地址：1994252448
************************************************************
3.可变数据类型
可变数据类型：list(列表)、dict(字典)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#列表
a=list()
print("列表a修改以前地址：{}".format(id(a)))
a.append(20)
print("列表a修改以后地址：{}".format(id(a)))
a.append(False)
print("列表a修改以后地址：{}".format(id(a)))
a.append("hello")
print("列表a修改以后地址：{}".format(id(a)))
print("***"*20)
#字典
a=dict()
print("字典a修改以前地址：{}".format(id(a)))
a["name"]="zhangsan"
print("字典a修改以后地址：{}".format(id(a)))
a["age"]=18
print("字典a修改以后地址：{}".format(id(a)))
a["sing_dog"]=True
print("字典a修改以后地址：{}".format(id(a)))
print("***"*20)
输出结果：
1
2
3
4
5
6
7
8
9
10
列表a修改以前地址：2067294579016
列表a修改以后地址：2067294579016
列表a修改以后地址：2067294579016
列表a修改以后地址：2067294579016
************************************************************
字典a修改以前地址：2067294527992
字典a修改以后地址：2067294527992
字典a修改以后地址：2067294527992
字典a修改以后地址：2067294527992
************************************************************
三.重点总结
1.不可变数据类型：数值类型(int、float、bool)、string(字符串)、tuple(元组)
2.可变数据类型：list(列表)、dict(字典)
3.可变数据类型更改值后，内存地址不发生改变；不可变数据类型更改值后，内存地址发生改变
猜你喜欢:

列表是Python复合数据类型中功能最多的。列表包含用逗号分隔并括在方括号([])中的项目。在某种程度上，列表类似于C中的数组。它们之间的区别是，属于列表的所有项目都可以具有不同的数据类型。
示例
可以使用切片运算符([]和[：])访问列表中存储的值，其中的索引从列表开头的0开始，一直到-1结束。加号(+)是列表串联运算符，星号(*)是重复运算符。例如-#!/usr/bin/python
list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
print list # Prints complete list
print list[0] # Prints first element of the list
print list[1:3] # Prints elements starting from 2nd till 3rd
print list[2:] # Prints elements starting from 3rd element
print tinylist * 2 # Prints list two times
print list + tinylist # Prints concatenated lists
输出结果
这产生以下结果-['abcd', 786, 2.23, 'john', 70.2]
abcd
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.2, 123, 'john']