#============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数据类型转换============

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