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

时间:2023-03-08 16:10:55
第三节 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","",45]
   s = ""
   for item in l:
   s = s + str(item)
   print(s)
      输出结果是:
        jasonhy12345
  #如果列表里都是字符串,那么我们就可以直接调用join()方法
  l = ["jasonhy","",""]
  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","",45]
 l.append([67,"89"])
 print(l)
    输出结果是:
       ['jasonhy', '123', 45, [67, '89']]
 #以迭代的形式进行添加
 l = ["jasonhy","",45]
 l.extend([67,""])
 print(l)
    输出结果是:
       ['jasonhy', '123', 45, 67, '89']

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

 #在指定位置进行添加
 l = ["jasonhy","",45]
 l.insert(2,"")
 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","",45]
  l.clear()
  print(l)
    输出结果是:
       []
 #删除指定位置的元素,并获取这个元素
 l = ["jasonhy","",45]
 s = l.pop(1)
 print(s,l)
    输出结果是:
      123 ['jasonhy', 45]
 #删除指定的元素
 l = ["jasonhy","",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","",45]
  print(l.count(""))
    输出结果是:
       1

    功能五:反转

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

    案例:

  l = ["jasonhy","",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 = ["","",""]
  l.sort()
  print(l)
     输出结果是:
        ['123', '45', '67']
 l = ["",[1,5,6,7],"","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("","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}