python有七大数据类型：
（1）数字（Number）：int(整型，长整型)，float(浮点型)，complex(复数）
（2）布尔（Boolean）：True,False
（3）字符串(String)：“Python”，‘python’
（4）列表（List）：[1,2,3,4]，[1,2,3,[1,2,3],"hello”]
（5）字典（Dictionary）:{1:"hello",2:"world"}
（6）元组（Tuple）：（1,2,3，“hello”,"world"）
（7）集合（Set）:{1,2,3，“hello”}
注：也有说python有六大数据类型，其中把布尔型放在了数字类型中。
不可变类型有4个：数字、布尔、字符串、元组
可变类型有3个：列表、字典、集合
可变数据类型是指内容可以随着函数的执行发生变化
不可变数据类型则是从初始化到结束都是不可改变的
下边来具体看一下每一种类型
一、数字（Number）
1. int （整型，长整型）
- 在python之中将整型和长整型合在了一起，在python3中只有int，没有long int 和long long int
- 可以用 sys模块的maxsize来获取系统支持的最大整数
import sys
print(sys.maxsize)
输出结果为：
92233720368547758072. float (浮点型）
- 浮点数可以用小数点的形式表示，
- 也可以 用科学技术法的形式表示（可以用e或者E）
例如: m = 3e2 （3e2代表3乘以10的2次方），此时m= 300
n = 3E2 （E与e的含义相同，都是表示10的多少次方），此时 n = 300
f = 0.01
m = 5e3
n = 5E3
print('f=',f,'m=',m,'n=',n)
输出的结果为：
f= 0.01 m= 5000.0 n= 5000.03. complex（复数）
- 复数由实数部分和虚数本分组成，在python中常用a+bj或者complex(a,b)表示，其中a表示复数的实部，b表示复数的虚部，并且复数的实部a和虚部b都是浮点型
- 用real函数获取实部值，用imag获取虚部值
- 用conjuate()求复数的共轭复数（共轭复数就是实部相同，虚部的符号相反）
c = 10 + 20j
d = complex(5, 10)
# c.real 实部 c.imag 虚部 c.conjugate 共轭复数
print(c, d, c.real, c.imag, c.conjugate())
输出的结果如下：
(10+20j) (5+10j) 10.0 20.0 (10-20j)二、布尔（Boolean）
- 布尔类型是只有True和False两种值（注意单词首字母要大写）的数据类型。
- 常用的布尔运算包括and、or、not三种，布尔类型值可以相加，但一旦相加，类型就会转换为int类型
运算
结果
x and y
只有x和y同时为True时，结果为True
x or y
只要x和y其中一个为True时，结果为True
not x
取反，即x为True时，结果为False
a = True b = False print(a and b) print(a or b) print(not a) print(a+b) # 当两个布尔型进行算数运算时就会转换成int类型 输出结果如下： False True False 1
三、字符串类型（String）
-
String类型是我们所熟知的类型，定义字符串值的时候可以用单引号，也可以用双引号
a = 'hello'
b = "world"
print(a,b)
输出结果为：
hello world四、列表
1. 创建列表
- 变量名 = [元素1,元素2,元素3,......,元素n]
- 列表中的数据称为列表的元素，元素之间用逗号分隔
- 同一个列表中可以有多个数据类型
- 列表中的元素是可以重复的
例如：
list1 = [1,2,3,4] 其中1,2,3,4就是列表的元素
list2 = [1,2,3,'hello',12] 同一个列表中可以有多个数据类型
list3 = [1,2,3,4,1,2,3] 列表中的元素是可以重复的
2. 列表的索引
- 列表每一个元素都对应一个整数型的索引值，可以通过索引值来得到相应的元素值。
- 列表支持元素的正向索引和反向索引。正向索引即索引值为正，从0开始；反向索引即索引值为负，从-1开始。若是反向索引，则-1为末尾元素对应的索引编号。
- 这里需要注意，正向索引值为正，从0开始，反向索引值为负，从-1 开始
list1 = [1,2,3,4,'hello']
print("列表list1的第一个值：",list1[0])
print("列表list1的最后一个值：",list1[-1])
输出结果如下：
列表list1的第一个值： 1
列表list1的最后一个值： hello3. 列表的切片
-
列表切片是指截取列表中的分元素，将截取的元素从新生成一个子列表
-
切片是从左到右进行的
-
格式为： 新列表 = 旧列表[起始值:终止值] （需要注意的是这里的切片位置是左闭右开的，也也就是说生成的新列表包含起索引对应的元素，但不包含终止索引对应的元素）】
list1 = [1,2,3,4,5,6,7,8,9]
list2 = list1[2:6]
# 2表示起始索引值为2，此处对应的元素值为3
# 6表示终止索引值为6，此处对应的元素值为7
list3 = list1[-6:-3]
print('list2=',list2)
print('list2=',list3)
输出结果为：
list2= [3, 4, 5, 6]
list2= [4, 5, 6]4. 列表加法和乘法
- 加法操作使用加号（+）完成，表示把加号两端的列表变量连接形成一个新列表
- 乘法操作使用星号（*）完成，表示对当前列表对象进行复制并连接，并形成一个新列表
list1 = [1,2,3]
list2 = [4,5,6]
list3 = list1+list2
list4 = list1*3
print("list3=",list3)
print("list4=",list4)
输出结果如下：
list3= [1, 2, 3, 4, 5, 6]
list4= [1, 2, 3, 1, 2, 3, 1, 2, 3]5.列表的修改
- 通过列表的索引进行修改
- 通过列表的切片进行修改
list1 = [1,2,0,4,5,6,7]
# 将索引值为2的元素的值修改为三
list1[2] = 3
print(list1)
list1[2:6]=[0,0,0,0]
print(list1)
输出结果为：
[1, 2, 3, 4, 5, 6, 7]
[1, 2, 0, 0, 0, 0, 7]6. 列表的删除
list删除有四种方法：del、pop、remove、clear
- del ：关键字，强制删除,可以只删除列表中某个索引对应的值，也可以直接将整个列表删除
- pop：如果不指定删除位置，则默认删除最后一个
- remove：删除指定的值（只删除第一次匹配到相等的元素），如果没有匹配到就会报错
- clear：清空列表，只是把列表中元素删除，但是列表还在
list1 = [1,2,1,4,5,6,7]
# 删除列表索引为1的值
del list1[1]
print("list1=",list1) #list2= [1, 1, 4, 5, 6]
list2= [1,2,1,4,5,6,7]
#默认删除列表中的最后一个值
list2.pop()
# 删除列表索引为1的值
list2.pop(1)
print("list2=",list2) #list1= [1, 1, 4, 5, 6, 7]
list3 = [1,2,1,4,5,6,7]
# s删除列表中值为1的元素，如果列表中有多个，则默认删除第一个
list3.remove(1)
print("list3=",list3) #list3= [2, 1, 4, 5, 6, 7]
list4 = [1,2,1,4,5,6,7]
# 请款列表
list4.clear()
print("list4=",list4) #list4= []7. 列表追加、插入和扩展
- append：在当前列表对象尾部追加元素
- insert：在当前列表的指定索引位置插入元素
- extend：对当前列表元素进行批量增加
list1 = [1,2,3,4,5,6,7]
list1.append(8)
list1.append([9,10])
print("list1 =",list1)
对应输出结果为：list1 = [1, 2, 3, 4, 5, 6, 7, 8, [9, 10]]
list2 = [1,2,4,5,6,7]
#在列表索引值为2的，增加元素3
list2.insert(2,3)
print("list2 =",list2)
对应输出结果为：list2 = [1, 2, 3, 4, 5, 6, 7]
list3 = [1,2,3]
list3.extend([4,5,6])
print("list3 =",list3)
对应输出结果为：list3 = [1, 2, 3, 4, 5, 6]8. 列表元素查找
- List运用index函数查找相应的元素，返回元素的索引，obj为元素值，start和end为 开始和结束索引（均可无）,如果元素不存在则报错
- 格式为： list.index(obj,start,end) 如果找不到的话就会报错
list1 = [1,2,3,4,5,6]
print(list1.index(4,1,5)) # 查找到了索引位置为3
print(list1.index(5)) # 查找到了索引位置为49. 列表相关的相关内置函数
| 列表函数 |
|
| 函数 |
含义 |
| len(list) |
列表元素个数 |
| max(list) |
返回列表元素最大值 |
| min(list) |
返回列表元素最小值 |
| list(seq) |
将序列转换为列表 |
| len(list) |
列表元素个数 |
| max(list) |
返回列表元素最大值 |
| min(list) |
返回列表元素最小值 |
| list(seq) |
将序列转换为列表 |
10. 多维列表
多维列表指的是列表的元素也是列表， 类似于多维数组
list1 = [1,2]
list2 = [1,2,3]
list3= [list1,list2]
print(list3)
输出如下：
[[1, 2], [1, 2, 3]]
# list3 是二维列表五、元组
1. 元组相关概述
- 元组是不可变数据类型，可以包含多种数据类型，python中复合数据类型中唯一一个不可变的
-
Tuple元组的创建 变量名 = (元素1,元素2,…,元素n)
-
元组从形式和列表相识，标志是“(”小括号 当元组中只有一个元素时，需要在元素后面加逗号 元组的访问也是通过索引来访问的，并且支持切片操作
2. 元组修改
元组是不可变数据类型，所以不能被修改，但可以重新赋值和用“+”进行连接产 生新的元组
# 元组可以包涵多种数据类型
tup1 = (1,2,3,4,'hello')
# 当元组只有一个元素时，需要在元素后面加一个逗号
tup2 = ("world",)
# 给元组进行+ 运算，从新生成一个新的元组
tup3 = tup1 + tup2
print(tup3)
输出结果为：
(1, 2, 3, 4, 'hello', 'world')3. 元组删除
元素值不允许删除的，但可使用del语句删除整个元组 需要注意的是，删除后的元组对象不可再次引用。
tup1 = (1,2,3,4,'hello')
del tup1
print(tup1)
#用del 将元组删除之后是不能在对之前的元组进行引用的，否则会报错
Traceback (most recent call last):
File "F:\course_study\python3\test\training\Type.py", line 89, in <module>
print(tup1)
NameError: name 'tup1' is not defined4. 与元组相关的内置函数
| 元组函数 |
|
| 函数 |
含义 |
| cmp(tuple1, tuple2) |
比较两个元组元素 Python3没有了 |
| len(tuple) |
计算元组元素个数 |
| max(tuple) |
返回元组中元素的最大值 |
| min(tuple) |
返回元组中元素的最小值 |
| tuple(seq) |
将列表转换为元组 |
| 元组方法 |
|
| 方法 |
描述 |
| tuple.count(value) |
统计元组中元素value的个数 |
| tuple.index(value, [start, [stop]]) |
返回列元组指定元素所在的索引位置，可以通过start和stop参数设置搜索范围。如果元素不存在则会报出异常 |
5. 元组与列表之间的转换
元组与列表是可以相互转换的
list1 =[1,2,3,45]
tuple1 = (91,2,3,4)
list2 = list(tuple1)
tuple2 = tuple(list1)
print(list2) #[91, 2, 3, 4]
print(tuple2) #(1, 2, 3, 45)6. 元组的优势
可以使函数返回多个值
可以使程序运行性能提升
一般来说，创建元组类型tuple的变量比列表类型list要快，而且占用更小的存储空间
使用元组是线程安全的
元组类型变量的元素不可更改性，可保证多线程读写时的安全问题
六、字典
1. 字典的创建
- 变量名={key1:value1, key2:value2,…, keyn:valuen}
- 字典的元素(value)是可变的，可以是任意数据类型，但键(key)值必须是不可变类型 在同一个字典变量中，键(key) 值必须是唯一的
stu = {"name":"zhangsan","age":21,"sex":"F"}
print(stu)
输出如下：
{'name': 'zhangsan', 'age': 21, 'sex': 'F'}
2. 字典的访问
- 字典是无序的，没有索引，只能通过键值（key）来获取元素
- 可以通过 字典名[key]，也可以通过字典名.get("age")
stu = {"name":"zhangsan","age":21,"sex":"F"}
print(stu)print(stu["name"],stu["age"]) #输出为：zhangsan 21
print(stu.get("name"),stu.get("age")) #输出为：zhangsan 213. 字典的修改
典通过对key值的引用对value值进行修改
stu = {"name":"zhangsan","age":21,"sex":"F"}
stu["sex"] ="M"
print(stu)
输出结果如下：
{'name': 'zhangsan', 'age': 21, 'sex': 'M'}4. 字典的删除
典通过del关键字进行删除
stu = {"name":"zhangsan","age":21,"sex":"F"}
del stu["age"]
print(stu)
输出如下：
{'name': 'zhangsan', 'sex': 'F'}5. 字典的增加
格式：字典名[key] = value
stu = {"name":"zhangsan","age":21,"sex":"F"}
stu["county"] = "China"
print(stu)
输出结果如下：
{'name': 'zhangsan', 'age': 21, 'sex': 'F', 'county': 'China'}6. 与字典相关的内置函数
| 字典函数 |
|
| 函数 |
含义 |
| cmp(dict1, dict2) |
比较两个字典元素 Python3没有了 |
| len(dict) |
计算字典元素个数 |
| str(dict) |
输出字典可打印的字符串表示 |
| 字典方法 |
|
| 方法 |
含义 |
| radiansdict.clear() |
删除字典内所有元素 |
| radiansdict.copy() |
返回一个字典的浅复制 |
| radiansdict.fromkeys() |
创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 |
| radiansdict.get(key,default=None) |
返回指定键的值，如果值不在字典中返回default值 |
| radiansdict.has_key(key) |
如果键在字典dict里返回true，否则返回false |
| radiansdict.items |
以列表返回可遍历的(键, 值) 元组数组 |
| radiansdict.keys() |
以列表返回一个字典所有的键 |
| radiansdict.setdefault(key,default=None) |
和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default |
| radiansdict.update(dict2) |
把字典dict2键/值对更新到对象radiansdict里 |
| radiansdict.values() |
以列表返回字典中的所有值 |
七、 集合
1. 集合的创建
- 格式：变量名 = {元素1,元素2,…,元素n}
- 集合与列表非常相似，，只是列表用的是[],而集合用的是{}，他们都是可以修改的，对元素的类型没有限制
set1 ={1,2,3,'qwd'}
print(set1)
输出如下：
{'qwd', 1, 2, 3}2. 集合的特性
- 无序性：元素之间没有确定的顺序。
- 互异性：不会出现重复的元素。
set1 = {1,2,3,5,"123",1,2,3}
print(set1)
输出为：
{1, 2, 3, 5, '123'}
# 输出的顺序不一定按照集合内的元素顺序输出，体现了集合的无序性
# 输出的元素没有重复的，体现了集合的互异性- 确定性：元素和集合只有属于或不属于的关系。
set1 = {1,2,3,5,"123",1,2,3}
print(set1)
print(1 in set1) #True
print( 1 not in set1) #False3. 集合增加元素
- add（）：添加一个元素
- update（）：同时添加多个元素
set1 = {1,2,3,5,"123",1,2,3}
set1.add(23)
print("ste1=",set1)
set2 = {1,2,3,4}
set2.update({5,6,7,8})
print("ste2=",set2)
输出结果如下：
ste1= {1, 2, 3, 5, '123', 23}
ste2= {1, 2, 3, 4, 5, 6, 7, 8}4. 集合删除元素
- discard() 和 remove() 方法删除集合中特定的元素
- 若删除的对象不存在，remove（）方法会引起错误， discard（）方法不会
5. 集合的数值运算
取set1 = {1,2,3} set2 = {3,4,5}
| 运算操作 |
运算符 |
含义 |
例子 |
| 交集 |
& |
取两集合公共的元素 |
set1 & set2 》{3} |
| 并集 |
| |
取两集合全部的元素 |
set1 | set2 》{1,2,3,4,5} |
| 差集 |
- |
取一个集合中另一集合没有的元素 |
set1 - set2 》{1,2} set2 - set1 》{4,5} |
| 对称差集 |
^ |
取集合 A 和 B 中不属于 A&B 的元素 |
set1 ^ set2 》{1,2,4,5} |
6. 集合中的frozenset
- set 集合是可变序列，程序可以改变序列中的元素
- frozenset 集合是不可变序列，程序不能改变序列中的元素
set1 ={1,2,3,4}
set2 = frozenset(set1)
# 现在集合set2是一个不可变集合，若对其进行修改，添加，则会报错到这里python的七大数据类型就介绍完了，如果有什么表述不清楚，或者有错的地方请指正