下篇：python的基本数据类型以及对应的常用方法(列表、元组、字典、集合)

为了日后便于查询，本文所涉及到的所有命令集合如下：

python中的基本数据类型有数字、字符串、布尔值、列表、元组、字典。就像每一个职业有自己特定的技能，比如医生能看病，农民能种田，每种数据类型也有属于自己的技能，我们把他们的技能称为方法。

现在就开始介绍这几种基本数据类型以及他们常用到的方法

对于列表
.append()  #末尾添加元素
.extend()   #末尾添加元素，能够传入一个列表，然后对传入的列表拆解后添加
.insert()    #指定位置添加元素
索引、切片、循环
对于元组
索引、切片、循环
记住一级元素不能被修改删除
对于字典
.get()   #得到传入key对应的value
.update()   #传入一个字典或者key1=value1，key2=value2这种形式进行字典更新
.keys()
.values()
.items()
for循环、索引
对于集合
集合1&集合2  #求交集
集合1|集合2  #求并集
集合1-集合2  #求差集，被减数和减数位置互换结果不同
集合1^集合2  #求交叉补集

列表

---

当有许多变量需要管理的时候，列表是其中的一种选择，列表的定义如下，其特征是以中括号[]括起来，元素之间以逗号分割，并不要求元素的类型一定相等。

testList1 = [1,2,3,"i","am","CodeScrew"]   #进行列表的定义

1.列表的常规操作

(1)取值：列表跟字符串一样，也可以通过索引取值或者切片取值

print(testList1[0]) #索引取值
print(testList1[0:3])  #切片取值，切片结果也是一个列表
print("1" in testList1)  #判断元素”1“是否存在列表中

(2)修改：与字符串不同的是，列表是可以被修改的，其在内存的存储方式有点像C语言的链表，每个元素是不连续的，但是可以通过地址找到。可以通过索引修改或者切片修改

testList1[0] = 2 #索引修改
testList1[0:3] = [3,2,1] #切片修改

(3)与其他类型的互相转换：可迭代的类型才能转换成列表，数字是不能转换成列表的，字符串转换成列表也是不能直接使用str()来进行转换的

#字符串转换成列表
testStr1 = "abcdefghi"
v1 = list(testStr1)
print(v1)  #输出结果为 ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']

#数字转换列表失败，因为数字是不可迭代的类型，通俗点就是不能被for循环读取
# testInt1 = 123
# v2 = list(testInt1)  #编译报错
# print(v2)

#列表转换成字符串，直接使用str()失败
testList1= [1,2,3,"i","am","CodeScrew"]
v3 = str(testList1)
print(v3)  #打印结果为 "[1, 2, 3, 'i', 'am', 'CodeScrew']"

#列表转换成字符串，需要自己写for循环
v4 = ""
for item in testList1:
    v4 += str(item)
print(v4)

#列表转换成字符串，如果列表中的元素全是字符串，可以使用join方法
testList2 = ["i","am","CodeScrew"]
v5 = "".join(testList2)
print(v5)

2.列表的常用方法

• .append(新元素)     #在列表的末尾添加新元素，元素可以是任意类型

  testList1= [1,2,3,"i","am","CodeScrew"]
  testList1.append("hello")
  print(testList1)
  # 打印结果为[1, 2, 3, 'i', 'am', 'CodeScrew', 'hello']

• .extend(可迭代对象)    #在列表的末尾添加新元素，与append不同的是其会把可迭代对象的元素拆分出来一个一个追加到列表末尾。append是将可迭代对象整体当作一个元素追加到末尾

  testList1= [1,2,3,2,"i","am","CodeScrew"]
  testList2 = [1,2,3]
  testList1.append(testList2)   #使用append进行元素追加
  print(testList1)
  # 打印结果为[1, 2, 3, 2, 'i', 'am', 'CodeScrew', [1, 2, 3]]
  
  testList1= [1,2,3,2,"i","am","CodeScrew"]
  testList2 = [1,2,3]
  testList1.extend(testList2)   #使用extend进行元素追加
  print(testList1)
  #打印结果为[1, 2, 3, 2, 'i', 'am', 'CodeScrew', 1, 2, 3]

• .insert(插入位置，要插入的值)     #在列表的特定位置插入元素

  testList1= [1,2,3,2,3,"i","am","CodeScrew"]
  testList1.insert(0,"hello")   #在列表的0索引处插入元素
  print(testList1)
  # 打印结果为['hello', 1, 2, 3, 2, 3, 'i', 'am', 'CodeScrew']

• .clear()      #清空列表的全部元素

  testList1= [1,2,3,"i","am","CodeScrew"]
  testList1.clear()
  print(testList1)
  # 打印结果为[]

• .pop(指定索引(可选))      #删除某个元素的值，并将该值返回

  testList1= [1,2,3,2,3,"i","am","CodeScrew"]
  v1 = testList1.pop()   #不加参数默认删除最后一个
  print(testList1)  #打印结果为[1, 2, 3, 2, 3, 'i', 'am']
  print(v1)   #打印结果为CodeScrew
  
  testList1= [1,2,3,2,3,"i","am","CodeScrew"]
  v1 = testList1.pop(5)   #删除索引值为5的元素“i”
  print(testList1)    #打印结果为[1, 2, 3, 2, 3, 'am', 'CodeScrew']
  print(v1)   #打印结果为i

• .remove(指定值)       #删除列表中值与指定值相同的元素，左边优先

  testList1= [1,2,3,2,3,"i","am","CodeScrew"]
  testList1.remove(2)   #删除值为2的元素，左边优先
  print(testList1)  #打印结果为[1, 3, 2, 3, 'i', 'am', 'CodeScrew']

• del 列表[索引]     #删除列表中对应索引的元素，可以是切片

• .copy()　　#列表的复制，这个是浅拷贝

  testList1= [1,2,3,"i","am","CodeScrew"]
  v1 = testList1.copy()   #将testList1的内容拷贝到v1中
  print(v1)
  # 打印结果为[[1, 2, 3, 'i', 'am', 'CodeScrew']]

• .count(输入值)    #查找列表中元素与输入值相同的个数

  testList1= [1,2,3,2,"i","am","CodeScrew"]
  v1 = testList1.count(2)   #查询列表中值为2的元素个数
  print(v1)
  # 打印结果为2

• .index(要查找的元素，起始位置，结束位置)   #查询元素的索引，从前往后找，返回第一个找到的元素的索引

  testList1= [1,2,3,2,3,"i","am","CodeScrew"]
  v1 = testList1.index(3)   #查询值为3的元素的索引
  print(v1)
  # 打印结果为2

• .reverse()    #将列表的元素进行反转

  testList1= [1,2,3,2,3,"i","am","CodeScrew"]
  testList1.reverse()   #进行列表的元素反转
  print(testList1)  #['CodeScrew', 'am', 'i', 3, 2, 3, 2, 1]

• .sort(key = None,reverse=True|False)    #将元素进行排序，默认从小到大排序，如果reverse = True，则为从大到到小排序,其中传参key在这里暂时不说

  testList1= [1,4,3,2]
  testList1.sort()   #进行列表的元素从小到大排序
  print(testList1)  #打印为[1, 2, 3, 4]
  testList1.sort(reverse = True)   #进行列表的元素从大大小排序
  print(testList1)  #打印为[4, 3, 2, 1]

元组

---

元组和列表有点类似，但和列表的不同点在于：列表元素有序，并且可以被修改。元组元素不能被修改，也不能增加或者删减元素，

元组的定义如下，其特征是以括号()括起来，元素之间以逗号分割，并不要求元素的类型一定相等。

testTuple1 = (1,2,3,"i","am","CodeScrew",)   #进行元组的定义，推荐定义元组的时候最后加一个逗号

元组的常规操作和列表几乎是一致的，也能够通过索引、切片来获取元素

这里有个注意点，元组的元素不能被修改指的是一级元素，二级及以上的元素是可以被修改的，如下面代码所示

testTuple1 = (1,2,[555,666],"hello")
#testTuple1[0] = 2
# 编译报错，一级元素不能被修改提示 'tuple' object does not support item assignment

testTuple1[2][0] = 666
print(testTuple1)
#打印结果为(1, 2, [666, 666], 'hello')
#分析下过程，testTuple1[2],得到了一级元素列表，testTuple1[2][0]得到了二级元素555，二级元素可以被修改

元组中只有两个方法，与列表雷同，这里不加以赘述了

• count()    #获取指定元素出现的次数
• index()    #获取指定元素的第一个索引

字典

---

字典的元素是无序的，定义一个字典使用print打印每一次看到的都是不一样的

字典的元素叫键值对，key：value这种的形式，其中key只能为数字、字符串、元组、布尔值，value可以为任何类型的任意值。当key相同时只能保存一个key

字典的定义如下，其特征是以括号{}括起来，元素必须是键值对，元素之间以逗号分割，并不要求元素的类型一定相等。

testDict = {
    "苹果" : "apple",
    "香蕉" : "banana"
}

字典的元素取值跟列表和元组有些许不同，其索引为元素中的key，而且不支持切片，如

testDict = {
    "苹果" : "apple",
    "香蕉" : "banana"
}
v1 = testDict["苹果"]  #通过key来取到value
print(v1)

对字典进行循环的时候默认是得到其所有的key，也是可以设置.keys()或者.items()来获取其他，如下面代码所示

testDict = {
    "苹果" : "apple",
    "香蕉" : "banana"
}
for item in testDict:
    print(item) #打印结果为苹果  香蕉

#上面的循环和for item in testDict.keys()  效果是一样的

for item in testDict.values():
    print(item)  # 打印结果为apple banana

for item in testDict.items():
    print(item)  # 打印结果为('苹果', 'apple') ('香蕉', 'banana')

for k,v in testDict.items():
    print(k,v)  #打印结果为苹果 apple  香蕉 banana

1.字典的常用方法

由于很多方法和列表的意义几乎是完全一样的，这里就不一一贴代码进行验证了

• .clear()   #删除所有元素
• .copy()   #复制字典
• dict.fromkeys(key序列，value值)    #通过传入key序列(列表、元组)来生成字典

  a1 = dict.fromkeys(["k1","k2"],0)
  print(a1) #打印结果为{'k1': 0, 'k2': 0}

• .get(key值)    #输入key值得到它所对应的值，如果不存在返回None，而直接索引取value的话，如果key不存在就会报错，如下面代码所示

  testDict1 = {
      "k1" : "v1",
      "k2" : "v2"
  }
  #testDict1["k11"]  使用这种形式如果key不存在，就会报错
  v1 = testDict1.get("k11")  #使用这种形式如果key不存在，返回none
  print(v1)

• .pop(key)   #删除某个元素的值，并获取。可以指定如果获取不到的时候返回的默认值
• .popitem()   #随机删除一个键值对，并返回
• .setdefalut(键，值)   #设置默认值，如果已经存在就不设置，返回值为设置的值或者已经存在的值

  testDict1 = {
      "k1" : "v1",
      "k2" : "v2"
  }
  
  v1 = testDict1.setdefault("k1","v11")  #设置键k1的默认值为v11，注意此时k1是有值的
  v3 = testDict1.setdefault("k3","v3")   #设置键k3的默认值为v3，注意此时没有k3
  print(testDict1)

• .update(字典)    #更新字典，如果字典有相应的键值对就覆盖，没有就创建，传参可以是一个字典，也是是key1 = value，key2 = value这种形式  

  testDict1 = {
      "k1" : "v1",
      "k2" : "v2"
  }
  
  testDict1.update({"k1":"v11","k2":"v22"})  #传入字典
  print(testDict1)  #打印结果为{'k1': 'v11', 'k2': 'v22'}
  testDict1.update(k5="v5")   #传入键值对
  print(testDict1)    #打印结果为{'k1': 'v11', 'k2': 'v22', 'k5': 'v5'}

集合

---

集合相比于列表、元组、字典，它的特性是只能由不同元素组成、无序、集合中元素必须是不可变类型

字典的定义如下，其特征是以括号{}括起来，元素之间以逗号分割，并不要求元素的类型一定相等。注意下与字典的不同，字典的元素必须是键值对

testSet = {"hello","world","CodeScrew"}  #使用常规的定义
#或者
#testSet = set(可迭代对象)   #使用set函数定义

#testFrozenSet = frozenset(可迭代对象)   #定义不可变集合

验证集合的三种特性：只能由不同元素组成、无序、集合中元素必须是不可变类型

testSet = {"hello","world","hello","CodeScrew"}
for item  in testSet:
    print(item)
#打印结果为
# hello
# CodeScrew
# world

#testSet = {[1,2],"hello"}   #列表为可变类型
#直接编译报错

1.集合的常用方法

• .add(添加的值)   #往集合中添加元素
• .clear()   #清空集合
• .copy   #拷贝集合
• .pop()   #随便删一个然后返回被删除的元素
• .remove(要删除的元素)   #删除特定元素，如果该元素不存在就报错
• .distartd(要删除的元素)   #删除特定元素，如果该元素不存在就忽略
• 集合1.intersection(集合2)   #求两个集合的交集，或者可以使用集合1&集合2的方式，比如会打篮球的人为集合1，会踢足球的人为集合2，要求两个都会玩的人，就是用集合的交集
• 集合1.union(集合2)   #求两个集合的并集，或者可以使用集合1|集合2的方式，比如会打篮球的人为集合1，会踢足球的人为集合2，要求只要会玩球的人，就是用集合的并集
• 集合1.diffrence(集合2)   #求两个集合的差集，也可以使用集合1-集合2 的方式，比如集合1-集合2只剩下集合1所独有的部分，集合2-集合1只剩下集合2独有的部分

• 集合1.symmetric_difference(集合2)    #求两个集合的交叉补集，也可以使用集合1^集合2 的方式，比如会打篮球的人为集合1，会踢足球的人为集合2，求出只会篮球或者只会足球的人

• 集合1.isdisjoint(集合2)   #两个集合是否存在交集
• 集合1.issubset(集合2)   #集合1是否为集合2的子集
• 集合1.issuperset(集合2)   #集合1是否为集合2的父集
• 集合1.update(集合2)    #用于来更新多个值集合1和集合2求并集并且赋值给集合1