#============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数据类型转换============
有时候,需要对数据内置的类型进行转换,数据类型的转换,只需要将数据类型作为函数名即可