python 列表字典元组等增删改查

Posted 2020-12-09 浮云飘渺的狮子

1. 元组

a. 定义和下标访问

元组的格式: (值,....) 如 s = (1,2,3)

元组的类型: tuple

元组的下标使用同字符串

 

注意:如果元组中只有一个元素,那么在定义时,需要加一个逗号 如：s = (4,)

 

b. 遍历

# for-in

 

t = (1,2,3,4,5,‘hello‘)
for v in t:
　　print(v)

 

# 循环配合下标方式 一

 

for i in range(len(t)):
　　print(t[i])
t = (1,2,‘ho‘)
for i in range(len(t)):
    print(t[i])
输出：
1
2
ho

 

# 循环配合下标方式 二

 

i = 0
while i < len(t):
　　print(t[i])
   i += 1

 

c. 嵌套元组

 

嵌套元组遍历：
t = (1,2,(‘h‘,‘o‘))
for v in t:
    if isinstance(v,tuple):  # isinstance(obj，type)判断参数obj是否是type型数据变量
        for v2 in v:
            print(v2)
    else:
        print(v)
输出：
1
2
h
o

 

d. 常用方法

功能同字符串

count() 用来统计元素个数

index() 查找元素的位置索引,如果不存在会报错

 

 

2. 列表

a. 定义和下标访问

定义格式:

变量名 = [值,....] a = [1,2,3]

变量名 = list(值) a = list(‘st‘) >>> print(a) >>> [‘s‘,‘t‘]

如何将列表型字符串转变成列表？？

 

c = ‘[1,2,3,4]‘
l = eval(c)
print(l)
>>>
[1,2,3,4]   其中eval（）函数中的参数为字符串（可以为表达式），其效果是将有效的python表达式求值并返回计算结果。
如：
x = 1
print(eval(‘x + 1‘))
>>> 2

 

下标:

0~len(列表名)-1

 

b. 遍历

同字符串或元组

 

 

c. 嵌套列表定义和遍历

isinstance(obj,type) -> bool

 

d. 排序和逆序

sort(reverse=False)
reverse()

c = [3,2,5] 
c.sort()              
print(c)
[2,3,5] #升序

c.sort(reverse=True)
print(c)
[5,3,2] #降序

c.reverse()
print(c)
[2,3,5] #将列表定义的顺序颠倒
# 手写实现列表逆序方法
def reverse_list(cl):
    # 定义一个空列表
    ret_l = []
    i = len(cl) - 1
    while i >= 0:
        ret_l.append(cl[i])  # s += c
        i -= 1
    return ret_l
print(reverse_list(cl))

还有一个平时用的比较多的需求：

# 实现对列表中的字典元素自定义顺序排序

l = [{‘name‘: ‘tom‘, ‘id‘: 3},{‘name‘: ‘tom‘, ‘id‘: 4}]
l.sort(key=lambda d: d[‘id‘]) # 此处的d不固定，可以随便写，只是表示列表中的一个字典对象而已
print(l)  # 根据id升序排列，
#  >>> [{‘name‘: ‘tom‘, ‘id‘: 3}, {‘name‘: ‘tom‘, ‘id‘: 4}]
l.sort(key=lambda d: d[‘id‘], reverse=True)
print(l)  # 根据id降序排序
#  >>>  [{‘name‘: ‘tom‘, ‘id‘: 4}, {‘name‘: ‘tom‘, ‘id‘: 3}] 

 

e. 常用方法

a = [‘1‘,‘2‘]

增：
            append()  a.append(‘k‘) >>> [‘1‘,‘2‘,‘k‘]
            extend()   a.extend([‘d‘,‘k‘]} >> [‘1‘,‘2‘,‘k‘,‘d‘,‘k‘]
            insert()    a.insert(1,‘n‘) >> [‘1‘,‘n‘,‘2’,‘k‘,‘d‘,‘k‘] 
　　　　　　　　　　　　　　# 如果指定下标超过元素正常范围，相当于追加
　　　　　　　　　　　　　　a.insert(14,‘n‘) >> [‘1‘,‘n‘,‘2’,‘k‘,‘d‘,‘k‘,‘n‘] 
        修：
            下标修改

        查：
            index()
            count()
            in (掌握) print(2 in a ) >>> True
            not in
        删：
            pop（）#括号中index参数可以不写 默认删除最后一个  a.pop(index)
            remove() # 删除 指定对象，当有多个相同对象时，只删除 第一个  a.remove(‘2‘)
            clear() # 清空但列表存在  a.clear() >> []
            del    # 全没了  del(a[1])  或者是 del   a[1]
注意：
# 在使用列表时，不要在循环遍历时删除元素
a = [‘1‘,‘2‘,‘3‘,‘4‘,‘5‘]
for c in a:
a.remove(c)
print(c)
[‘2‘,‘4‘]

 

3. 字典

a 定义(字典为可变类型）

字典定义格式

{key: value,....}

  

b 字典的元素的引用

a = {‘c‘: 1, ‘b‘: 2}

使用字典获取字典中的数据

格式:

①字典变量名[key]     # 理论，所有不可变的类型都可以做为key，
print(a[‘c‘])       # 只要是可hash的的对象都 可以做为key
　　　　　　　　　　　　# key一般情况下使用字符串类型的数据充当，
　　　　　　　　　　　　# 访问时，如果使用了不存在的key，会报错
②字典变量名.get(key) # 若不存在key对应的值，返回None，不会报错
print(a.get(‘c‘))

③a.setdefault(‘c‘) 可以查询键对应的值，同时还可以用来添加新的键值对，a.setdefault(‘d‘,‘name‘),本方法只限于字典使用

④update()
有相同的键会直接替换成 update 的值，没有则新增键值对:
>>> a = {1: 2, 2: 2}
>>> b = {1: 1, 3: 3}
>>> b.update(a)
>>> print b
{1: 2, 2: 2, 3: 3} 

 

c 遍历字典

四种遍历方式-看代码

d = {‘one‘: ‘星期一‘, ‘two‘: ‘星期二‘, ‘three‘: ‘星期三‘,‘haha‘:‘周末‘}
# 默认情况 下，使用for-in遍历时，会将所有的key遍历出来
① for k in d:
    print(f‘for-in:{k} --> {d[k]}‘) 
输出：   
for-in:one --> 星期一
for-in:two --> 星期二
for-in:three --> 星期三
for-in:haha --> 周末

② print(d.keys()) >>> dict_keys([‘one‘,‘two‘,‘there‘,‘haha‘])
for k in d.keys():
    print(f‘keys  :{k} --> {d[k]}‘)
③ values() 方法
for k in d.values():
　　print(f‘{k}‘)
④ items() 
for k, v in d.items():
　　print(f‘{k}--->{v}‘)

 

d. 字典增删改查

增：# 如果在赋值时，使用的key在字典中不存在，那么就是向字典中添加 数据 a[‘2‘] = ‘lihc‘

改：# 如果在赋值 时，使用的key在字典中存在，那么就修改这个key所对应的值

　　# key 是不能修改的，字典中的key 具有唯一性。

 

查： print(d[‘a‘])

print(d.get(‘a‘))

删：同list 但没有remove这个功能 另外 字典还有一个d.popitem() # 删除最后一个键值对

 

e. 无序字典和有序字典

在 python3.5之前， dict 类型是无序的 ，key无序，-> 写入顺序和显示顺序不同

在 pyhton3.5之后，都是有序

 

4. 集合定义和引用

集合的特性：

集合定义像字典

存储数据像列表

 

重要特性:

集合中的数据不允许重复，且是无序的（如果是数字，会默认进行升序排序）

 

作用：

利用集合的特性来对数据进行去除重复数据

 

定义：

　　set(可遍历的对象)

s = set(‘sda‘)
>>> {‘a‘,‘d‘,‘s‘}  变化中
s = set{}  定义一个空集合
    访问：
    注意： 集合是不支持下标访问的

 

4. set-list-tuple三者类型间转换

s = ‘hello‘
l = list(s)
print(set(l))
print(set(s))
print(str(l))
print(‘‘.join(set(l)))

 

5. 公共方法和内置函数

字符串、列表和元组均可以进行加和乘操作

字符串、列表和元组、字典均可以用in和not in 判断