二、列表、元祖、字典的方法

一、list：类，列表。  有序，可被修改。

list.append()      #对象.方法（...  ）
称为：list对象调用append方法。

 

1. 列表格式：使用中括号；
2. 列表中可以嵌套任何类型：数字，字符串、列表、布尔值.....
3. ☆ 索引取值 

   例：
   li = [1,2,3,'hello']
   a = li[2]
   print(a)
   
   输出；
   3

    

4. ☆ 切片，返回结果为列表

   例：
   li = [1,2,3,'hello']
   a = li[1:3]
   print(a)
   
   输出：
   [2,3]

    

5. ☆ for循环与while循环...
6. 索引修改...
7. 切片修改...
8. in操作,判断某个值是否存在列表中...
9. 取值操作

   例：
   li = [1,2,3,['23','dfs',['34']],'hello']
   a = li[3][2][0][1]
   print(a)
   
   输出：
   4

    

10. 转换：　　
    1. 字符串转换成列表，相当于内部使用for循环：

       例：
       a = 'dfsdfsf'
       i = list(a)
       print(i)
       
       输出：
       ['d', 'f', 's', 'd', 'f', 's', 'f']

        

    2. 列表转换成字符串：（列表中包含数字与字符串，需用for循环处理）

       例：
       li = [123,23,34,'df','sde']
       a = ''
       for i in li:
           a = a + str(i)
       print(a)
       
       输出：
       1232334dfsde

       列表只包含字符串：（可用join进行拼接）

       例：
       li = ['df','sde','ewdsd']
       i = ''.join(li)
       print(i)
       
       输出：
       dfsdeewdsd

        

内置方法：

1. ☆ append：将参数追加到列表末尾

   def append(self,p_object）

   例：
   li = ['df','sde','ewdsd']
   li.append('32')
   print(li)
   
   输出：
   ['df', 'sde', 'ewdsd', '32']

2. clear：清空列表

   def clear(self, *args, **kwargs)

   例：
   li = ['df','sde','ewdsd']
   li.clear()
   print(li)
   
   输出：
   []

3. copy：复制（浅拷贝）

   def copy(self, *args, **kwargs)

   例：
   li = ['df','sde','ewdsd']
   v = li.copy()
   print(v)
   
   输出：
   ['df', 'sde', 'ewdsd']

4. count：计算元素在列表中出现的次数

   def count(self, value)

   例：
   li = [11,22,33,44,22,'ewdsd']
   v = li.count(22)
   print(v)
   
   输出：
   2

5. ☆ extend：扩展，把元素追加到列表中进行扩展，相当于内部进行for循环，与append不同。（iterable可迭代对象，可被for循环，如字符串，列表）

   def extend(self, iterable)

   例：
   li = [11,22,33,44,22,'ewdsd']
   li.extend([11,23])
   print(li)
   
   输出：
   [11, 22, 33, 44, 22, 'ewdsd', 11, 23]

6. index：根据值获取当前索引值的位置，左边优先，没找到时报valueError。

   def index(self, start=None, stop=None)

   例：
   li = [11,22,33,44,22,]
   v = li.index(22,2,5)
   print(v)
   
   输出：
   4

7. ☆ insert：在指定位置插入元素

   def insert(self, index, p_object)

   例：
   li = [11,22,33,44,22,]
   li.insert(0,99)
   print(li)
   
   输出：
   [99, 11, 22, 33, 44, 22]

8. pop：删除某个值，默认删除最后一个（可指定索引），并可获得删除的值

   def pop(self, index=None)

   例：
   li = [11,22,33,44,22,]
   v = li.pop(1)
   print(li,v)
   
   输出：
   [11, 33, 44, 22]  22

9. remove：删除指定的值，左边优先。

   def remove(self, value）

   例：
   li = [11,22,33,44,22,]
   li.remove(22)
   print(li)
   
   输出：
   [11, 33, 44, 22]

   del删除列表：
   del li[1]
   del li[2:5]

10. reverse：将当前列表进行反转

    def reverse(self, *args, **kwargs)

    例：
    li = [11,22,33,44,22,]
    li.reverse()
    print(li)
    
    输出：
    [22, 44, 33, 22, 11]

11. sort：默认从小到大排序，reverse为True时反转。

    def sort(self, key=None, reverse=False)

    例：
    li = [11,22,33,44,22,]
    li.sort(reverse=True)
    print(li)
    
    输出：
    [44, 33, 22, 22, 11]

二、tuple ：元祖；元素的一级元素不能被修改，不能被增加或删除，可索引、切片、for循环，可迭代对象、转换。有序

1. 结构类型：

   tu = (11,22,33,44,)

2. 方法（与 list 的方法类似）：　　
   1. count：获取元素在元组中出现的次数
   2. index：根据值获取当前索引值的位置

三、dict：字典；用大括号，有键值对：key&value 。   

1. 基本结构： 

   info = {
       'k1':'v1',  #键值对
       'k2':'v2',
   }

2. key：不能是字典、列表；         注意：作为布尔值（True/False : 1/0）时，需注意字典中是否已有数字0,1的存在，key值相同时只取一个值。
3. value ：可以是任何值，如列表、元祖、布尔值...　
4. 字典是无序的；
5. 可用key值进行索引，可删除，不可切片；
6. 可用 in 判断，默认为判断key值；
7. 可用 while 与 for 循环：

   for k,v in info.items():
       pritn(k,v)

    

内置方法：

1. clear：清除
2. copy：浅拷贝
3. fromkeys：根据序列，创建字典，并指定统一的值。

   def fromkeys(*args, **kwargs)

   例：
   v = dict.fromkeys(['k1','999',123],123)
   print(v)
   
   输出：
   {'k1': 123, '999': 123, 123: 123}

4. ☆ get：根据key获取值，key不存在时，可以指定输出值（默认为None）

   def get(self, k, d=None)

   例：
   info = {
       'k1':'v1'
   }
   v = info.get('k111',1)
   print(v)
   
   输出：
   1

5. ☆ items：字典的集合

   def items(self)

   例：
   info = {
       'k1':'v1',
       'k2':'v2',
   }
   for k,v in info.items():
       print(k,v)
   
   输出：
   k1 v1
   k2 v2

6. ☆ keys：key的集合   ☆ value 用法相同。

   def keys(self)

   例：
   info = {
   'k1':'v1',
   'k2':'v2',
   }
   for v in info.keys():     #for v in info.values():
   print(v)
   
   输出：
   k1       #v1
   k2       #v2

7. pop ：删除并获取值，key不存在时，可以指定输出值；

   def pop(self, k, d=None)

   例：
   info = {
       'k1':'v1',
       'k2':'v2',
   }
   v = info.pop('k222',1)
   print(v)
   
   输出：
   1

   popitem：随机删除键值

   def popitem(self)

   例：
   info = {
       'k1':'v1',
       'k2':'v2',
       'k3':'v3',
   }
   k,v = info.popitem()
   print(k,v)
   
   输出：
   k3 v3

8. setdefault：设置键值对，如key已存在则不添加，不存在时则添加，并返回所对应的value。

   def setdefault(self, k, d=None)

   例：
   info = {
       'k1':'v1',
       'k2':'v2',
       'k3':'v3',
   }
   v = info.setdefault('k11','123')
   print(info,v)
   
   输出：
   {'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k11': '123'} 123

9. ☆ update：更新字典。

   def update(self, E=None, **F）

   例：
   info = {
       'k1':'v1',
       'k2':'v2',
   }
   info.update(k3='v3',K4=23)        #info.update({'k3':'v3','K4':23})
   print(info)
   
   输出：
   {'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'K4': 23}

 

四、enumerate：返回列举的对象，获取索引编号与值，默认为‘0‘。把一个列表变成索引-元素对，

test = ['zero','one','two','three']
for index,item in enumerate(test,1):
    print(index,item)

输出：
1 zero
2 one
3 two
4 three

#使用for循环不可修改索引编号，较局限
test = ['zero','one','two','three']
for i in range(len(test)):
    print(i,test[i])

输出：
0 zero
1 one
2 two
3 three

 

 

五、bool：布尔值（True & False：1 & 0）

• 对于 None、""、()、[]、{}、0  返回 False ，其余基本为 True。