第三节 Python基础之数据类型(列表，元组，字典)

　　　列表，简单说就是用[]括起来的一大堆数据，这些数据我们叫做元素，元素与元素之间用","隔开，这些元素可以是数字，布尔值，字符串，列表等等，基本所有的数据类型都可以放在列表里边，同时这些元素是可以修改的。

　　例如：

　　　#假如我们有这么一个列表
　　　l = ["jasonhy",[12,False],45,True]
　　　#删除索引1的元素
　　  del l[1]
 　　 print(l)
　　　　　　#再次输出列表l的结果为：
　　　　　　['jasonhy', 45, True]

　　#将一个字符串变成一个列表
　　print(list("jasonhy"))
　　　　　　输出结果是：
　　　　　　　　　['j', 'a', 's', 'o', 'n', 'h', 'y']

　　　　功能一：将列表转换成字符串

　　 #假如有一个列表既有字符串又有数字，那么这个时候想将列表转换成字符串就只能依次的遍历了
　　 l = ["jasonhy","123",45]
　　 s = ""
　　 for item in l:
    　　 s = s + str(item)
　　 print(s)
　　　　　　输出结果是：
　　　　　　　　jasonhy12345

　　#如果列表里都是字符串，那么我们就可以直接调用join（）方法
　　l = ["jasonhy","123","45"]
　　s = "".join(l)
　　print(s)
　　　　　输出结果是：
　　　　　　　　jasonhy12345

　　　功能二：向列表中添加指定的元素

　　def append(self, p_object): 
        """ L.append(object) -> None -- append object to end """ #添加一个元素到列表的末尾
        pass

  def extend(self, iterable): 
       """ L.extend(iterable) -> None -- extend list by appending elements from the iterable """ #以迭代的方式遍历每一个元素添加到列表中
       pass

  def insert(self, index, p_object): 
       """ L.insert(index, object) -- insert object before index """ #在指定的位置插入元素
       pass

　　　　案例：

　#以追加的形式添加
　l = ["jasonhy","123",45]
　l.append([67,"89"])
　print(l)
　　　　输出结果是：
　　　　　　　['jasonhy', '123', 45, [67, '89']]

　#以迭代的形式进行添加
　l = ["jasonhy","123",45]
　l.extend([67,"89"])
　print(l)
　　　　输出结果是：
　　　　　　 ['jasonhy', '123', 45, 67, '89']

　　　　注：append（）和 extend（）的区别就是，append（）在添加元素的时候，以一个整体的形式将元素追加在原列表的末尾，而extend（）则遍历每个元素，将遍历到元素添加到原列表中

　#在指定位置进行添加
　l = ["jasonhy","123",45]
　l.insert(2,"67")
　print(l)
　　　　输出结果是：
　　　　　　　['jasonhy', '123', '67', 45]

　　　　功能三：删除元素

    def clear(self): 
        """ L.clear() -> None -- remove all items from L """ #移除列表里面的所有的元素
        pass
　　

　 def pop(self, index=None): 
        """
        L.pop([index]) -> item -- remove and return item at index (default last). #根据索引删除列表里的元素，默认删除列表的最后一个元素，并可以获取被删除的元素
        Raises IndexError if list is empty or index is out of range. 
        """
        pass

 　def remove(self, value): 
        """
        L.remove(value) -> None -- remove first occurrence of value. #删除被选中的元素
        Raises ValueError if the value is not present.
        """
        pass

　　　　案例：

　 #全部删除
　 l = ["jasonhy","123",45]
　 l.clear()
　 print(l)
　　　　输出结果是：
　　　　　　　[]

　#删除指定位置的元素，并获取这个元素
　l = ["jasonhy","123",45]
　s = l.pop(1)
　print(s,l)
　　　 输出结果是：
　　　　　　123 ['jasonhy', 45]

　#删除指定的元素
　l = ["jasonhy","123",45]
　l.remove(45)
　print(l)
　　　 输出结果是：
　　　　　　 ['jasonhy', '123']

　　　　功能四：计算列表里元素出现的次数

   def count(self, value): 
        """ L.count(value) -> integer -- return number of occurrences of value """ 返回元素value出现的次数
        return 0

　　　　案例：

　 l = ["jasonhy","123",45]
　 print(l.count("123"))
　　　　输出结果是：
　　　　　　　1

　　　　功能五：反转

   def reverse(self): 
        """ L.reverse() -- reverse *IN PLACE* """ 将元素位置反转
        pass

　　　　案例：

　 l = ["jasonhy","123",45]
　 l.reverse()
　 print(l)
　　　　输出结果是：
　　　　　　　[45, '123', 'jasonhy']

　　　　功能六：排序

   def sort(self, key=None, reverse=False): 
        """ L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """ #key接收的是一个函数的返回值，这个返回值就是一个权值，可根据权值进行大小排序，reverse接收的是False或者True表示是否逆序
        pass

　　　　案例：

　 l = ["67","123","45"]
　 l.sort()
　 print(l)
　　　 　输出结果是：
　　　　　　 　['123', '45', '67']

　l = ["67",[1,5,6,7],"123","jasonhy"]
　def rule(x):
    '''
    　　定义一个rule函数
    　　:param x:
   　　 :return: 按照长度返回
    '''
   　 return len(x)
　l.sort(key=rule)
　print(l)
　　　　输出结果是：
　　　　　　　['67', '123', [1, 5, 6, 7], 'jasonhy']
　注：如果加上reverse=True就按照降序进行排序

 　　　　元组（tuple），有点类似列表，但是它的元素不可以修改，在这里，我们说的元素不可以修改指的是一级元素不可以修改，不能增加元素，也不能删除元素，元组长得像我们定义的函数，所以我们为了区别，可读性，往往在元组的最后一个元素后面加上一个逗号，比如：t = ("jasonhy",18,)，元组就两个方法，一个是count(self, value)，是用来统计元素value出现的次数的；另一个是index(self, value, start=None, stop=None)，是用来查找元素value出现的位置索引，start和stop分别用来设置查找的起始位置和终止位置。

　　　　字典（dict），它的元素是在一个大括号里面，比如：d={"name":"jasonhy","age":18}，这就是字典的表现形式，从这个表现形式，我们也可以看出，字典里面的元素是一种键值对的关系，也就是key-value之间的一种关系，value可以是任何值，但是key必须是不可修改的，比如列表，由于列表里的元素是可修改的，那就不能作为key值了，在这里我们可以这样理解，小张可以拥有一支钢笔和一个笔记本，如果把小张改成小王，小张和小王还是同一个人吗？这样答案就显然了。

　　　字典还有一个特点就是无序。

　　　功能一：元素删除

　　　#定义了一个字典t
　　　t = {"name":"jasonhy","age":18}

　　#直接调用del，根据key来删除
　　del t["age"]
　　print(t)
　　　　　输出结果是：
　　　　　　　　　{'name': 'jasonhy'}

　 #调用内置函数pop(k, d=None)，也是根据key进行删除，并将被删除的元素返回
　 s = t.pop("age")
　 print(s,t)
　　　　　输出结果是：
　　　　　　　　　18 {'name': 'jasonhy'}

　 #调用内置函数popitem（），随机删除，删除的是一个键值对，以元组的形式将被删除的键值对返回
　 s = t.popitem()
　 print(s,t)
　　　　　输出结果是：
　　　　　　　　　('age', 18) {'name': 'jasonhy'}
　　　　　　　　　注：这个结果是随机的

　 #我们现在有一个需求就是要变量字典t里面的元素
　 for item in t:
    　　print(item)
　　　　　　　 输出结果是：
　　　　　　　　　　　 age
　　　　　　　　　　　 name
   我们发现直接遍历的是，实际遍历的是key值，那么我们想要value值呢？

　#现在需求是要变量字典t里面的元素的value
　for item in t.values():
    　　print(item)
　　　　　　　 输出结果是：
　　　　　　　　　　　 jasonhy
　　　　　　　　　　　 18

　　　我们希望的是key和value都能遍历出来

　#现在需求是要变量字典t里面的元素的value
　for item in t.values():
    　 print(item)
　　　　　　　输出结果是：
　　　　　　　　　　 ('name', 'jasonhy')
　　　　　　　　　　 ('age', 18)

　　　　　功能二：生成一个字典

　　@staticmethod 
    def fromkeys(*args, **kwargs): 
        """ Returns a new dict with keys from iterable and values equal to value. """ #根据×args迭代之后生成key值，每个key对应的value值都是一样的
        pass

　　　　　 案例：

　　l = (12,45)
　　d = ("ab","cd")
　　print(dict.fromkeys(l,d))
　　　　　输出结果是：
　　　　　　　　　{12: ('ab', 'cd'), 45: ('ab', 'cd')}

　　　　　功能三：获取value值

    def get(self, k, d=None): 
        """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """ #根据k来获取value值，如果k不在字典里边，返回就是d指定的值，d默认是None
        pass

　　　　　案例：

　　t = {"name":"jasonhy","age":18}
　　print(t.get("12","has not key"))
　　　　　输出结果是：
　　　　　　　　　has not key

　　　　　功能四：更新元素

    def setdefault(self, k, d=None): 
        """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """ #将一个key值设置到字典里边，如果这个key以及存在字典里，那就不设置进去了
        pass

    def update(self, E=None, **F): 
        """
        D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
        If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
        If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
        In either case, this is followed by: for k in F:  D[k] = F[k]  #以字典的形式进行更新，如果这个字典里面的key已经在原字典存在了，就将原字典里的value值进行更新，如果不存在，就添加到原字典里面
        """
        pass

　　　　　案例：

　　t = {"name":"jasonhy","age":18}
　　t.setdefault("age",20)
　　print(t)
　　　　　输出结果是：
　　　　　　　　　{'name': 'jasonhy', 'age': 18}
　　

　 t.update({"loc":"广州","age":20})
　 print(t)
　　　　　输出结果是：
　　　　　　　　　{'loc': '广州', 'name': 'jasonhy', 'age': 20}