python3基本数据类型

#============Python的标椎数据类型============
python3有6种标准数据类型

number  数字
string  字符串
tuple   元组
list    列表
set     集合
dictionary 字典

python3的6种标椎数据类型中:

不可变数据: number(数字) string(字符串) tuple(元组)
可变数据: list(列表) set(结合) dictionary(字典)

#============Python的数值运算============
#数值运算

print(5 + 4)   #加法
print(4.3-1)   #减法
print(3 * 7)   #乘法
print(2/4)     #2除以4得到一个浮点数 0.5
print(2 // 4)  #2除以4得到一个整数 0
print(4 % 3)   #取余
print(2 ** 6)  #乘方

#============Python的列表(list)============
#列表(Python 中使用最频繁的数据类型)

list = ['a','b','c','d','e','f']
tinylist = [1,2,3]
print(list)      #列出所有列表
print(list[0])   #列出第一个元素
print(list[1:3]) #列出第二个到第三个元素
print(list[2:])  #列出第三个元素开始的所有元素
print(list * 2)  #列表输出两次
print(list[4:6]) #列出第5个元素到6个元素
print(list + tinylist) #连接列表

#列表设置步长----重要

list = ['a','b','c','d','e','f','g','h','i','j']
#索引正向:0   1   2   3   4   5   6   7   8   9
#索引反向:-10 -9  -8  -7  -6  -5  -4  -3  -2  -1

list[1:4:2] 表示在索引1到索引4的位置设置为步长2
步长的格式: 变量 = [开始索引:结束索引:长度]
步长的计算公式: 当前索引+步长=下一个索引

print(list[1:8:3])

首先截取的第一个元素是开始的元素即: b
第二个截取的元素: 第一个元素索引(1)+步长=第二个元素索引 1+3=4 所以第二个截取的元素为: e
第三个截取的元素: 第二个元素索引(4)+步长=第三个元素索引 4+3=7 所以第三个截取的元素为: h
第四个截取的元素: 第三个元素索引(7)+步长=第四个元素索引 7+3=10 上面可以看出我们是没有10这个索引的,后面的就不会再截取了
如果你的元素很多,就会按照以上的方法一直截取,直到最后无法再截取
以上就是截取的流程,所以我们一共就截取了三个元素: b e h

步长为负数时就从后往前截取,计算公式不变
步长为负数时,省略开头索引,对应的是从后往前的第一个元素开始截取
步长为负数时,省略结尾索引,对应的是从前往后的第一个元素为结束

print(list[:2:-3]) #按照公式截取的元素为: j g d
print(list[7::-2]) #按照公式截取的元素为: h f d b

#============Python的元组(tuple)============
元组与列表类似,不同之处在于元组的元素不能更改,元组写在"()"中,元组的元素之间用","隔开

tuple = ('lakers','lebron','james','23','25.4')
wade = ('heat','wade','3')
print(tuple)      #输出元组的所有元素
print(tuple[0])   #输出元组的第一个元素
print(tuple[1:4]) #输出从第二个元素到第四个元素
print(tuple[2:])  #输出从第三个元素开始的所有元素
print(tuple * 2)  #输出两次元组
print(tuple + wade) #连接元组

输出结果:

('lakers', 'lebron', 'james', '23', '25.4')
lakers
('lebron', 'james', '23')
('james', '23', '25.4')
('lakers', 'lebron', 'james', '23', '25.4', 'lakers', 'lebron', 'james', '23', '25.4')
('lakers', 'lebron', 'james', '23', '25.4', 'heat', 'wade', '3')

元组与字符串类型,索引都是从"0"开始,"-1"从末尾开始的位置,截取方式与字符串相似
重要: 虽然tuple的元素不可改变,但它可以包含可变的对象,比如list列表

tuple = (['lebron','james'],['lakers','23'])
print(tuple)
print(tuple[0])

可以看出元组中包含了一个列表,这时列表就成了元组的元素,在列表中我们可以改变列表中元素

tuple = (['lebron','james'],['lakers','6'])
print(tuple)
print(tuple[1])

构造包含0个或1个元素的元组比较特殊,所以有一些额外的语法规则:

tuple = () #空元组
tuple = (23,) #一个元素时,还是需要在后面加","号

string、list和tuple都属于sequence(序列)

注意：
    与字符串一样,元组的元素不能修改
    元组也可以被索引和切片,方法一样
    注意构造包含"0"或"1"个元素的元组的特殊语法规则
    元组也可以使用"+"操作符进行拼接

#============Python的集合(set)============
集合(set)是由一个或数个形态各异的大小整体组成的,构成集合的事物或对象称作元素或是成员
基本功能是进行成员关系测试和删除重复元素
可以使用大括号"{ }"或者"set()"函数创建集合,注意:创建一个空集合必须用"set()"而不是"{ }",因为"{ }"是用来创建一个空字典
创建格式:

parame = {value01,value02,...}
或者
set('value')

重要: 使用集合时,重复的元素会被自动去掉,只显示一个

a = {'james',23,'lakers','wade',3.0,'rose',23}
print(a)

输出结果: 集合元素23只显示了一次

{3.0, 'lakers', 'wade', 'rose', 'james', 23}

set()中有重复的元素时也会自动去掉

b = set('lebroneeeeeeeeee')
print(b)

输出结果:

{'n', 'e', 'r', 'l', 'b', 'o'}

#集合的运算

a = set('abcdefghi')
b = set('adcsheshou')
print(a)
print(a - b)  #a和b的差集(将a的集合中有的但b集合中没有的取出)
print(b - a)  #b和a的差集(将b的集合中有的但a集合中没有的取出)
print(a | b)  #a和b的并集(a和b所有的)
print(a & b)  #a和b的交集(a和b都有的)
print(a ^ b)  #a和b中不同时存在的元素(相当于上述两个差集结果的总和)

输出结果为:

{'h', 'd', 'e', 'f', 'g', 'b', 'c', 'i', 'a'}
{'b', 'i', 'f', 'g'}
{'u', 'o', 's'}
{'h', 's', 'd', 'e', 'f', 'g', 'u', 'b', 'o', 'c', 'i', 'a'}
{'h', 'd', 'e', 'c', 'a'}
{'s', 'f', 'g', 'u', 'b', 'o', 'i'}

#判断元素是否存在,成员测试

name = {'james','wade','kobe','lrving'}
if 'james' in name:
    print('james在集合中')
else :
    print('james不在集合中')

输出结果为:

james在集合中

#============Python的字典(dictionary)============
字典(dictionary)是Python中另一个非常有用的内置数据类型
列表是有序的对象集合,字典是无序的对象集合,两者之间的区别在于: 字典当中的元素是通过键来存取的,而不是通过偏移存取
字典是一种映射类型,字典用"{ }"标识,它是一个无序的"键(key):值(value)"的集合
重要: 键(key)必须使用不可变类型,也就是说"键(key)"只能使用"数字,字符串,元组"这三种数据类型
在同一个字典中,键(key)必须是唯一的

test = {} #空字典
test['one'] = '字典一'
test[2] = '字典二'
full = {'name':'james','year':'34','number':'23','web':'www.james.com','cj':'25.4'}

print(test['one'])   #输出键为'one'的值
print(test[2])       #输出键为'2'的值
print(full)          #输出完整的字典
print(full.keys())   #输出所有键
print(full.values()) #输出所有值
print(full['name'])  #输出full字典中键为'name'的值

#输出结果为:

字典一
字典二
{'name': 'james', 'year': '34', 'number': '23', 'web': 'www.james.com', 'cj': '25.4'}
dict_keys(['name', 'year', 'number', 'web', 'cj'])
dict_values(['james', '34', '23', 'www.james.com', '25.4'])
james

#构造函数"dict()"可以直接从键值对序列中构建字典如下:

>>> dict([('james', 1), ('wade', 2), ('lrving', 3)])
{'james': 1, 'wade': 2, 'lrving': 3}
>>>

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>>

>>> dict(james=1, wade=2, lrving=3)
{'james': 1, 'wade': 2, 'lrving': 3}

重要:
    字典类型也有一些内置的函数,例如clear() keys() values()等
    字典是一种映射类型,它的元素是键值对
    字典的关键字必须为不可变类型,且不能重复
    创建空字典使用{}

#============Python数据类型转换============
有时候,需要对数据内置的类型进行转换,数据类型的转换,只需要将数据类型作为函数名即可