列表类中提供的方法

1.列表特点：

a.中括号括起来

b.逗号分隔每个元素

c.列表中的元素可以是数字、字符串、列表、布尔值……所有的都能放进去

d.列表是一个集合，内部可以放置任何东西

e.可以通过索引取值，可以一直往里找

li = [1, 2, 3, ['yu', 'gh', 'jk', ['py', 16, 'op'], 23], True, 'cyx']
v = li[3][3][0][1]
print(v)

f.可以通过切片取值，切片结果也是列表

li = [1, 2, 3, ['yu', 'gh', 'jk', ['py'], 23], True]
print(li[3])
print(li[2:4])

g.支持for循环，支持while循环

li = [1, 2, 3, ['yu', 'gh', 'jk', ['py'], 23], True, 'cyx']
for item in li:
    print(item)

h.字符串一旦创建不可修改，列表元素可以被修改，因为列表在内存中是以链表的形式存储，链表表示各元素在内存中不连续，但上一个元素的位置会同时存储下一个元素的位置信息，可以通过索引或切片的方式修改

字符串可以通过索引取值，但是不能修改这个值（因为字符串创建后不可更改）

列表既可以通过索引取值，也可以通过索引修改这个值

li = [1, 2, 3, ['yu', 'gh', 'jk', ['py'], 23], True, 'cyx']
li[1] = [11, 22, 33, 44]
print(li)

li = [1, 2, 3, ['yu', 'gh', 'jk', ['py'], 23], True, 'cyx']
li[1:3] = [20, 30]
print(li)

i.删除，可以通过索引或切片删除

li = [1, 2, 3, ['yu', 'gh', 'jk', ['py'], 23], True, 'cyx']
del li[1]
print(li)

li = [1, 2, 3, ['yu', 'gh', 'jk', ['py'], 23], True, 'cyx']
del li[0:4]
print(li)

j.支持in操作

li = [1, 2, 3, ['yu', 'gh', 'jk', ['py'], 23], True, 'cyx']
v = 20 in li
print(v)

k.字符串转换成列表，list在内部使用for循环

s = 'qwertyuioopasdfghjkl'
v = list(s)
print(v)

l.因为数字不能进行for循环，而列表在转换时利用的就是for循环，所以数字不能用list转换为列表

m.列表转换为字符串

m1.写for循环：列表里既有数字，也有字符串

s = ''
li =[11, 22, 33, '123', 'alex']
for i in li:
    s = s + str(i)
print(s)

s = ''
li = [1, 2, 3, ['yu', 'gh', 'jk', ['py', 16, 'op'], 23], True, 'cyx']
for i in li:
    s = s + str(i)
print(s)

m2.用str转换只能在列表整体加''，不能去掉列表内部逗号

li = [1, 2, 3, ['yu', 'gh', 'jk', ['py', 16, 'op'], 23], True, 'cyx']
v = str(li)
print(v)

m3.''.join()：只有字符串时可以使用

li =['123', 'alex']
s = ''.join(li)
print(s)

o.在python里none表示空值，iterable表示可迭代的对象（字符串、聊表）

p.append：原来值最后追加

li = [11, 22, 33, 44]
li.append(5)
print(li)

q.clear：清空

li = [11, 22, 33, 44]
li.clear()
print(li)

r.copy：浅拷贝

li = [11, 22, 33, 44]
v = li.copy()
print(v)

s.count：计算元素出现的次数

li = [11, 22, 33, 44, 22]
v = li.count(22)
print(v)

t.extend：扩展原列表，内部有执行for 循环，所以参数需为可迭代对象

append：把参数当成整体追加

li = [11, 22, 33, 44, 22]
li.append([5656, 'cyx'])
print(li)

li = [11, 22, 33, 44, 22]
li.extend([5656, 'cyx'])
print(li)

li = [11, 22, 33, 44, 22]
for i in [5656, 'cyx']:
    li.append(i)
print(li)

li = [11, 22, 33, 44, 22]
li.extend('集合吧')
print(li)

u.index: 根据值获取当前值索引位置，默认左边优先，找到第一个就不找了，可以设置起始和结束位置

li = [11, 22, 33, 44, 22]
v = li.index(22)
print(v)

v.insert ：在指定索引位置插入元素

li = [11, 22, 33, 44, 22]
li.insert(2, 'cyx')
print(li)

w. pop 默认删除最后一个值，并获取删除的值，可以加索引指定删除

li = [11, 22, 33, 44, 22]
v = li.pop()
print(li)
print(v)

li = [11, 22, 33, 44, 22]
v = li.pop(3)
print(li)
print(v)

x.remove删除列表中的指定值，左边优先

li = [11, 22, 33, 44, 22]
li.remove(22)
print(li)

注： pop remove del[0] del[0:3] clear都表示删除

y.reverse将当前列表进行翻转、颠倒

li = [11, 22, 33, 44, 22]
li.reverse()
print(li)

z.sort 排序，默认从小到大排序

列表是有序的，元素可以被修改

li = [11, 22, 33, 44, 22]
li.sort()
print(li)

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

2.元组：对列表的二次加工，书写格式为加()，元素不可被修改，不能被增加或者删除

一般写元组的时候，在最后一位加,，不会报错，为了将元组和参数区分开来

a.索引取值，可以一直往里找

tu = (11, 22, 33, 44, 22)
v = tu[0]
print(v)

tu = (11, 22, 33, [(33,44)], 44, 22,)
v = tu[3][0][0]
print(v)

b.切片取值，结果仍是元组

tu = (11, 22, 33, 44, 22)
v = tu[0]
print(v)

c.for 循环，所以元组也属于可迭代对象

tu = (11, 22, 33, 44, 22)
for item in tu:
    print(item)

d.字符串、列表、元组都是可迭代对象，字符串和列表都可以转换成元组

li = [11, 22, 33, 44, 22]
v = tuple(li)
print(v)

s = 'sgjdkhie'
v = tuple(s)
print(v)

元组转换为列表

tu = (11, 22, 33, 44, 22)
v = list(tu)
print(v)

元组转换为字符串

1)元素都是字符串时

tu = ('hui', 'qwe')
v = ''.join(tu)
print(v)

2)元素为字符串和数字组合时，需写for 循环

s = ''
tu = (123, 'qwe')
for i in tu:
    s = s + str(i)
print(s)

e.元组也是有序的

f.元组的一级元素不可修改、删除、增加

tu = (11, 22, 33, [(33,44)], 44, 22,)
tu[3][0] = 567
print(tu)

[(33,44)]中的33不可修改，因为它属于(33,44)的一级元素

g.count:获取指定元素在元组中出现的次数

h.index获取某个值得索引位置

3.字典dict：

a.基本结构

逗号分隔，一个元素称为键值对

键值对中的value可以是任何值，可以嵌套

数字、字符串、元组（不能被修改）、布尔值（可能会和0,1重复）可以做为key值，列表（动态的）不可以作为字典的key

字典保存时是按照哈希表来保存的，字典在内存中生成的是一张表格，key到内存里会转换成一堆数字和数字有对应关系

创建字典：

info = {'k1': 'v1', 'k2': 'v2'}

b.字典是无序的，每次print，元素顺序会变

c.索引方式找到指定值

info = {'k1': 18, 'k2': True, 'k3': [11, [], (), 22, 33,{'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44)}
v = info['k1']
print(v)

info = {'k1': 18, 'k2': True, 'k3': [11, [], (), 22, 33,{'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44)}
v = info['k3'][5]['kk3'][0]
print(v)

d.支持del删除

info = {'k1': 18, 'k2': True, 'k3': [11, [], (), 22, 33,{'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44)}
del info['k1']
print(info)

info = {'k1': 18, 'k2': True, 'k3': [11, [], (), 22, 33,{'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44)}
del info['k3'][5]['kk1']
print(info)

e.不支持while循环，支持for 循环，默认for循环时只输出key，也可以定义只输出value，也可以定义获取键值对

info = {'k1': 18, 'k2': True, 'k3': [11, [], (), 22, 33,{'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44)}
for item in info:
    print(item)

info = {'k1': 18, 'k2': True, 'k3': [11, [], (), 22, 33,{'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44)}
for item in info.keys():
    print(item)

info = {'k1': 18, 'k2': True, 'k3': [11, [], (), 22, 33,{'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44)}
for item in info.values():
    print(item)

info = {'k1': 18, 'k2': True, 'k3': [11, [], (), 22, 33,{'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44)}
for k, v in info.items():
    print(k, v)

e.k值重复时，只能保留一个；布尔值和0或1重复时，也无法显示；没有0或1时，布尔值可以正常显示

info ={ 1: 'asdf', "k1": 'asdf','k1': "123",(11,22): 123,}
print(info)

info ={ 1: 'asdf', "k1": 'asdf', True: "123",(11,22): 123,}
print(info)

info ={ 7: 'asdf', "k1": 'asdf', True: "123",(11,22): 123,}
print(info)

f.clear/copy

g.fromkeys根据序列创建字典，并且指定统一的值

dic ={ 'k1': 'v1', "k2": 'v2'}
v = dict.fromkeys(['qw', 123, 'uio'], 123)
print(v)

dic ={ 'k1': 'v1', "k2": 'v2'}
v = dict.fromkeys('dffhkji', 123)
print(v)

h.通过索引的方式取key,若key不存在会报错

通过get方式取key，若key不存在会输出空值，不会报错，还可以指定第二个参数，表示如果key不存在，默认把第二个参数返回，key值存在的话，会直接忽略第二个参数

dic = {'k1': 'v1', "k2": 'v2'}
v = dic.get('k333')
print(v)

dic = {'k1': 'v1', "k2": 'v2'}
v = dic.get('k333', 1111)
print(v)

i.pop删除的同时，可以获得删除的value，参数可以加默认值，当key不存在时，会将默认值返回

dic = {'k1': 'v1', "k2": 'v2'}
v = dic.pop('k1')
print(dic, v)

dic = {'k1': 'v1', "k2": 'v2'}
v = dic.pop('k1111', 'lop')
print(dic, v)

j.popitem不加参数，随机删键值对，并获取值

dic = {'k1': 'v1', "k2": 'v2'}
v = dic.popitem()
print(dic, v)

dic = {'k1': 'v1', "k2": 'v2'}
k, v = dic.popitem()
print(dic, k, v)

k.setdefault的功能为设置值，如果key已经存在，不设置，但会获取当前key对应的value;如果key不存在，则会设置，并获取当前key对应的值

dic = {'k1': 'v1', "k2": 'v2'}
v = dic.setdefault('k1', 123)
print(dic, v)

dic = {'k1': 'v1', "k2": 'v2'}
v = dic.setdefault('k1111', 123)
print(dic, v)

l.update已经存在的覆盖掉，不存在的更新进去，用两种调用方式

dic = {'k1': 'v1', "k2": 'v2'}
dic.update({'k1': 123, 'k3': 'uiop'})
print(dic)

dic = {'k1': 'v1', "k2": 'v2'}
dic.update(k1=123, k2=456, k3='klj')
print(dic)

m.支持in操作，默认判断key

dic = {
    "k1": 'v1'
}

v = "k1" in dic
print(v)

v = "v1" in dic.values()
print(v)

n.enumerate用法：同时获得索引和值

list1 = ["这", "是", "一个", "测试"]

for index, item in enumerate(list1):

print index, item

>>>

0 这

1 是

2 一个

3 测试