python之数据类型

字符串

• 切片，拼接

str1 = "5"
str2 = "8"
print(str1+str2)

a = "i love "
c = "python haha"
print(a+c[:6])

• 原始字符串：忽略掉转义符
• 元素前加"r"字段

str1 = "hello\now"
str2 = r"hello\now"

print(str1+"\n")
print(str2)

内置函数

元祖tuple

• 有序不可变
• 只可读不可写
• 逗号才是元祖的关键

创建

tuple1 = 1, 2, 3
tuple2 = ("a", "b", "c")
tuple3 = 5,

print(tuple1)
print(tuple2)
print(tuple3)

列表list 有序可变

• 一个被打了激素的数据
• 列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据
• 列表是有序的，有索引值，可切片，方便取值。

列表操作

insert：有两个参数；可以往列表的任意位置插入元素

增
append()方法

• append：参数只能是一个；将一个对象作为一个整体添加到列表中，注意：一个对象可以是一个元素，也可以是一个数组。

list1 = [1, 2, 3, 'abc']

list1.append("hello")
print(list1)

list1.append(["nihao", "world"])
print(list1)

extend()方法

• extend：参数为一个；事实上是使用一个列表来扩充另一个列表

list1 = [1, 2, 3, 'abc']

list1.extend(['hello', 'world'])
print(list1)

list1.extend([4, 5, 6])
print(list1)

insert()方法

• 在列表任意位置插入元素

list1 = [1, 2, 3, 'abc']

list1.insert(0, 'hello')
print(list1)

list1.insert(-1, 'world') #参数还支持负数
print(list1)

删
remove()方法

• 指定一个待删除的元素，也就是说参数是元素

list1 = ['咸鱼', '鲶鱼', '鲨鱼', '甲鱼']

list1.remove("咸鱼")
print(list1)

list1.remove("甲鱼")
print(list1)

pop()方法

• 将列表中指定元素删除，参数是一个索引值
• 默认删除列表最后一个

list1 = ['咸鱼', '鲶鱼', '鲨鱼', '甲鱼']

list1.pop()
print(list1)

list1.pop(1)
print(list1)

clear()方法

• 清空列表所有元素

list1 = ['咸鱼', '鲶鱼', '鲨鱼', '甲鱼']

list1.clear()
print(list1)

def语句

• 切片删除，没有返回值
• 之前删除变量

list1 = ['咸鱼', '鲶鱼', '鲨鱼', '甲鱼']

del list1[0:2]
print(list1)

list1 = ['咸鱼', '鲶鱼', '鲨鱼', '甲鱼']

del list1
print(list1) ##会报错，因为del语句直接把list1变量给删除了

改

list1 = ["wo", 4, "ni", "father"]
list1[3] = "mother"
print(list1)
list1[0:2]=["ni", 5]
print(list1)

查

• 通过索引值获取元素

list1 = ['咸鱼', '鲶鱼', '鲨鱼', '甲鱼']

print(list1[0])

print(list1[-1]) #获取最后一个元素

print(list1[-2]) #获取倒数第二个

• 元素互换

list1 = ['咸鱼', '鲶鱼', '鲨鱼', '甲鱼']

print(list1)
list1[0], list1[-1] = list1[-1], list1[0]
print(list1)

• 切片
• 列表切片并不会修改列表自身的结构和数据，它其实是为列表创建了一个新的拷贝并返回

list1 = ['咸鱼', '鲶鱼', '鲨鱼', '甲鱼']

print(list1[0:2])
print(list1)

for i in list1:
    print(i)

其他操作

list2 = [2, 3, 5, 1, 10, 1]
统计某个元素在列表中出现的次数
print(list2.count(1))

返回某个元素在列表中第一次出现的索引值；可以限定查找的范围
print(list2.index(3))
print(list2.index(1, 2, 5))

将整个列表翻转
list2.reverse()
print(list2)

排序
list2.sort()
print(list2)

排序后翻转（从大到小）
list2.sort(reverse=True)
print(list2)

字典 dict 无序

• 字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。
• python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。
• 可哈希表示key必须是不可变类型，如：数字、字符串、元组。

字典操作

增

dic={"age":18,"name":"salted"}
dic["li"]=["a","b","c"]
print(dic)

dic={"age":18,"name":"salted"}
dic.setdefault("k","v")
print(dic)
dic.setdefault("hobby")
print(dic)
dic.setdefault("k","v1")
print(dic)
# 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。

删
只能删除键，不能单独删除值

dic={"age":18,"name":"salted"}
dic_pop=dic.pop("age")
print(dic_pop)
dic_pop=dic.pop("sex","查无此项")
print(dic_pop)
# pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值

dic={"age":18,"name":"salted"}
del dic["name"]
print(dic)

dic={"age":18,"name":"salted"}
dic_pop=dic.popitem() # 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回
print(dic_pop)

dic={"age":18,"name":"salted"}
dic.clear()# 清空字典
print(dic)

改

dic1={"age":18,"name":"salted"}
dic2={"age":20,"hobby":"woman"}
dic1.update(dic2) # 将dic2所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic1中
print(dic1)

dic1={"age":18,"name":"salted"}
dic1["hobby"]="man"
dic1["age"]=88
print(dic1)

查

dic1={"age":18,"name":"salted"}
value=dic1["name"] # 没有会报错
print(value)

dic1={"age":18,"name":"salted"}
#如果有则返回对应的值，没有则返回默认返回值
value=dic1.get("age")
print(value)
value=dic1.get("hobby")  #返回默认值none
print(value)
value=dic1.get("hobby","查无此项") #返回值"查无此项"
print(value)

其他操作

dic1={"age":18,"name":"salted"}
for i in dic1.items():
	# 将键和值作为元祖列出
    print(i)
for key,value in dic1.items():
	#输出键值对
    print(key,value)
for i in dic1:
	#迭代键
    print(i)

dic={"age":18,"name":"salted"}
keys = dic.keys() #输出键
print(keys,type(keys))
value = dic.values() #输出值
print(value,type(value))

集合 set 无序

集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。
以下是集合最重要的两点：

• 去重，把一个列表变成集合，就自动去重了。
• 关系测试，测试两组数据之前的交集、差集、并集等关系

集合操作

创建集合

set1=set({1,2,"hello"})
set2={1,2,"hello"}
print(set1,'\n',set2)

增

set1={1,2,"hello"}
set1.add("python") 
print(set1)
set1.update("A") #update：迭代着增加
print(set1)
set1.update([1,2,3])
print(set1)

删

set1={1,2,"hello"}
set1.remove('hello')
print(set1)
set1.pop()
# 随机删除一个数
print(set1)

set1={1,2,"hello"}
set1.clear()
# 清空合集
print(set1)

set1={1,2,"hello"}
del set1
# 删除合集
print(set1)

其他操作

交集

set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}
print(set1 & set2)
print(set1.intersection(set2))

并集

set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}
print(set1 | set2)
print(set2.union(set1))

差集

set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}
print(set1 - set2)
print(set2.difference(set1))

反交集
显示set1和set2不共存的项

set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}
print(set1 ^ set2)
print(set1.symmetric_difference(set2))

子集，超集

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1 < set2)
print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。
print(set2 > set1)
print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集

frozenset不可变集合，让集合变成不可变类型

set1 = {1,2,3,4,5,6}
s = frozenset(set1)
print(s,type(s))
s.add(7) # 不可以修改,会报错

总结

按存储空间（从低到高）

按存值个数区分

按可变不可变区分

按访问顺序区分

enumerate：枚举

• 对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

li = ['甲','乙','丙','丁']
for i in li:
    print(i)
for i in enumerate(li):
    print(i)
for index,value in enumerate(li):
    print(index,value)
for index,value in enumerate(li,100): #从哪个数字开始索引
    print(index,value)