1列表的增删改查

1.1 修改列表元素

通过下标获取元素，然后重新赋值： 列表名[下标] = 新的值

Ps:下标不能越界

names = ['周星驰', '张家辉', '刘德华', ' 黄渤', '杨洋']
names[4] = '陈奕迅'
print(names)

-->
['周星驰', '张家辉', '刘德华', ' 黄渤', '陈奕迅']

1.2 列表的其他操作

（1）len(列表):获取列表的长度(元素的个数)

（2）列表1+列表2：让列表1和列表2的元素组合在一起产生一个新的列表

（3）列表*数字：让列表中的元素重复N次，产生一个新的列表

print(len([1, 2, 3, 4, 5]))
print(len(names))

-->
5
5


new_names = names + ['周杰伦', '王力宏']
print(new_names)

-->

['周星驰', '张家辉', '刘德华', ' 黄渤', '陈奕迅', '周杰伦', '王力宏']


print([1,2]*3)

-->

[1, 2, 1, 2, 1, 2]

1.3 in ,not in操作

元素 in 列表：判断指定的元素是否在指定的列表中

result = '高以翔' not in names
print(result)

-->
True

1.4获取列表中的最大的元素和最小元素

max(列表) 最大

min(列表) 最小

print(max([1, 34, 67, 8]))
print(max(['a', 'hj', 'uio', 'z']))
print(min([1, 45, 89, 0, -1, 8]))

-->
67
z
-1

在不采用内置函数的情况下获取最大值：

numbers = [-1, -23, -56, -2, 445, -1]
max1 = numbers[0]
for item in numbers:
    if item > max1:
        max1 = item
print(max1)

-->
445

1.5其他方法

（1）count:获取指定元素子列表中出现的次数

print(numbers.count(-1))

-->

2

获取 -1 在列表numbers中出现的次数

（2）extend:将序列中的每一个元素，添加到列表中

names.extend(['王祖贤'])
print(names)

-->
['周星驰', '张家辉', '刘德华', ' 黄渤', '陈奕迅', '王祖贤']

(3)index:获取指定元素在指定列表中的索引，如果元素出现多次，只取第一次出现的位置

print(names.index('张家辉'))

-->
1

(4)reverse：反向列表中的元素(直接操作在原列表，不会产生新的列表)

numbers = [1, 22, 3, 4, 89]
numbers.reverse()
print(numbers)

-->
[89, 4, 3, 22, 1]

(5)sort 对列表元素进行排序，默认从小到大

numbers = [1, 42, 45, 6, 90]
numbers.sort()  # 升序
print(numbers)

-->
[1, 6, 42, 45, 90]

如果想要逆序 需要添加参数 reverse=True

numbers.sort(reverse=True)  # 降序
print(numbers)

-->
[90, 45, 42, 6, 1]

(6)clear 清空列表中的元素

numbers.clear()
print(numbers)

-->
[]

等同于 numbers = []

(7)copy 将列表中的元素全部拷贝一份创建一个新的列表

names = ['张三', '李四']
new_names1 = names.copy()
print(new_names1)

-->
['张三', '李四']

等同于切片 new_names1 = names[:]

2 元组

2.1什么是元组

元组就是不可变的列表，列表中除了可变的操作以外，其他操作都适用于元组

元组使用()将元素包含起来，多个元素之间用,隔开，元素可以是任何类型

2.2改，增，删相关操作不能作用于元组，查可以用

colors = ('red', 'green', 'yellow', 'purple')

a.查和列表的查一模一样，没有区别

colors = ('red', 'green', 'yellow', 'purple')
print(colors[1])
print(colors[0:3])
print(colors[0::2])
for item in colors:
    print(item)
    
-->
green
'red', 'green', 'yellow', 'purple'
'red', 'green', 'yellow'
red
green
yellow
purple

b. len()函数

print(len(colors))

-->
4

c. in , not in

print('red' in colors)
-->
True

d. + 和 *

print((1, 2) + (3, 4))
print((1, 2) * 2)

-->
(1,2,3,4)
(1,2,1,2)

f. 补充

（1）获取元组的元素

通过多个变量分别获取元祖的元素(变量个数和元祖元素个数一样)

names = ('name1', 'name2', 'name3')
x, y, z = names   
print(x, y)

-->
name1,name2

通过变量名前加*可以把变量变成列表，获取多个元素

names = ('name1', 'name2', 'name2_2', 'name2_3', 'name3')
first, *midel, last = names 
print(first, midel, last)

*name1, name = names #让name获取最后一个元素，其他的部分作为列表name1的元素
print(name1, name)

name, *name1 = names # 让name获取第一个元素，剩下的部分作为列表name1的元素
print(name)

-->
name1,  [name2, name2_2, name2_3]   name3
[name1,name2,name2_2,name2_3],name3
name[1] 

3.字典

字典是一种容器类型的数据类型，存的值是以键值对的形式。

字典是可变的(可以增删改)，但是是无序的，所以不能使用下标

键是唯一的

键值对： 键：值（key：value） 在键值对中，key是形式，值才是真正要保存的东西。

键：理论上是任何不可变的数据类型，但是实际开发的时候一般使用字符串作为key

值：可以是任意类型数据

3.1声明一个字典

a.创建一个字典变量

dict1 = {}  # 创建一个空的字典
print(type(dict1))

-->
<class 'dict'>

dict2 = {'a': 1, 'b': 'abc', 10: [1, 2, 3], ('a', 'b'): 'abc'}
print(dict2)
-->
{'a': 1, 'b': 'abc', 10: [1, 2, 3], ('a', 'b'): 'abc'}


dict2 = {'a': 1, 'b': 'abc', 'a': 100}
print(dict2)
-->
{'a': 1, 'b': 'abc', 'a': 100}

b.将其他数据类型转换成字典

ict3 = dict([(1, 2), (2, 3)])  # 了解
print(dict3)

3.2字典的增删改查

a.查：获取字典的元素的值

字典获取元素的值是通过key来获取的

格式： 字典[key]

person = {'name': '路飞', 'age': 17, 'face': 90}
print(person['name'], person['face'])
-->
路飞，90

如果key不存在，会报错

# print(person['aaa']) 

字典.get(key)

print(person.get('name'))
-->
路飞
print(person.get('aaa')) 
-->
none

使用get 如果key不存在，返回none

如果获取字典的元素的值时，确定Key值确定存在，使用字典[key]语法去获取值。不确定的时候使用get方法获取值

b.增加元素\修改元素

通过key获取字典元素，然后赋值。当key本身就存在的时候，就是修改元素的值；不存在的时候就是给字典添加键值对。

person['height'] = 1.8
print(person)
-->
{'name': '路飞', 'age': 17, 'face': 90, 'height': 1.8}

person['age'] = 18
print(person)
-->
{'name': '路飞', 'age': 18, 'face': 90, 'height': 1.8}

c.删除 ： 删除的是键值对

语法：del 字典[key] 如果删除的key不存在会报错

del person['face']
print(person)

-->
{'name': '路飞', 'age': 18, 'height': 1.8}

语法：字典.pop(key) 会返回被删除的键值对对应的值

age = person.pop('age')
print(person, age)

3.3相关的数组属性

字典.keys():获取字典所有的key,返回值的类型是dict_keys,但是可以当做列表来使用

字典.values():获取字典所有的值value

字典.items():将字典中所有的键值对转换成一个一个的元组，key作为元组的第一个元素，value作为元组的第二个元素

student_dict = {'name': '张三', 'study_id': "py1805001", 'scores': {'english': 60, 'math': 100}}
keys = student_dict.keys()
print(keys,tytpe(keys))

for key in keys:
    print(key)
print(student_dict.values())

print(student_dict.items())

3.4 遍历字典

a. 直接遍历字典获取到的是所有的key

for key in student_dict:
    print(key,student_dict[key])

b.遍历直接获取到key和value

for key,value in student_dict.items():
    print(key,value)
    
for value in student_dict.values():
    print(value)

3.5列表中有字典，字典中有字典，字典中有列表

声明一个变量，作用是用来存储一个班级的学生的信息。其中学生的信息包括姓名、性别、年龄、电话
至少存三个学生信息

class1 = [
    {'name': '张三', 'age': 23, 'sex': '男', 'tel': '15300022777'},
    {'name': '李四', 'age': 25, 'sex': '女', 'tel': '12779922'},
    {'name': '王二麻子', 'age': 20, 'sex': '男', 'tel': '12553'}
]

class1 = {
    'name': 'py1805',
    'address': '19-1',
    'students':[
        {'name': '张三', 'age': 18},
        {'name': '李四', 'age': 28},
        {'name': '王五', 'age': 20},
    ]
}

3.6其他操作

1.fromkeys()

dict.fromkeys(序列, value)：创建一个新的字典，序列中的元素作为key,value作为值

new_dict = dict.fromkeys(['abc', 'dcc', '123'], '100')
print(new_dict)

2.in

Key in 字典：判断字典中是否含有指定的keyw

dog_dict = {'color': 'white', 'age': 3,  'type': '土狗'}
print('color' in dog_dict)  # 判断的是键是否存在
print('white' in dog_dict)

3.update

字典1.update(字典2)：使用字典2的键值对去更新字典1中的键值对。如果字典2中对应键值对在字典1中不存在，就添加。存在就更新。

dict1 = {'1': 'a', '2': 'b'}
dict1.update({'1': 'aaa', '3': 'bbb'})
print(dict1)

4.集合

集合(set)也是一种容器类型的数据类型，数据放在{}中，多个自检用逗号隔开。集合是无序的，所以不能通过索引取值。可变，可以增删改 元素不能重复

集合是可以进行数序中集合相关的操作：判断是否包含，求交集，并集，差集，补集

4.1声明集合

a.声明一个变量，赋一个集合值

set0 = set()  #创建一个空的集合
set1 = {1,23,4,1}
print(set1,type(set1))

b.将其他的数据转换当成集合

set2 = set('abc1233h')  # 将其他数据转换成集合，自带一个去重的功能
print(set2)
set3 = set([12, 'abc', 'hh', 32, 12, 'abcn'])
print(set3)
print(list(set3))

4.2增删改查

a.查：遍历

ps:集合没有办法单独获取某一个元素

for item in set2:
    print(item)

b.增

Add

语法： 集合.add(元素):在指定的集合中添加指定的元素

set1 = {1, 2, 3}
set1.add(100)
print(set1)

update

语法：集合1.update(集合2)：将集合2中的元素添加到集合1中，自动去重

set1.update({'abc', 'ss'})
print(set1)

c.删

remove

语法:集合.remove(元素）:在指定集合中删除指定的元素

set1.remove('ss')
print(set1)

pop

语法：pop是随机删除一个 慎用

set1.pop()
print(set1)

4.3判断是否包含

语法：集合1 >= 集合2 判断集合1中是否包含集合2

print({1, 2, 3, 4} >= {1, 4})  # True
print({1, 2, 3, 4} <= {1, 2})  # False

4.4数字的集合运算

a. 求并集： |

print({1, 2, 3} | {2, 3, 4, 5})

b.求交集：&

print({1, 2, 3} & {2, 3, 4, 5})

c.求差集： -

print({1, 2, 3} - {2, 3, 4, 5})

d.求补集：^

print({1, 2, 3} ^ {2, 3, 4, 5})

4.5其他方法

Clear:清空集合

set1.clear()
print(set1, type(set1))

Len:获取长度