一、列表~续

1、 增、删、改、查

(1)、修改列元素

• 通过下标获取元素，然后重新赋值：列表名[下标] = 新的值。
• 注意：这儿的下标不能越界。

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

运行结果：
['周星驰', '张家辉', '刘德华', ' 黄渤', '陈奕迅']

(2)、列表的其它操作

• len(列表）：获取列的长度（元素的个数）
• 列表1 + 列表2 ：让列表1和列表2的元素组合在一个新的列表

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

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

print([1,2]*3)

运行结果：
5
['周星驰', '张家辉', '刘德华', ' 黄渤', '陈奕迅', '周杰伦', '王力宏']
[1, 2, 1, 2, 1, 2]

(3)、in,not in 操作

• 元素 in 列表 ： 判断制定的元素是否在一个列表

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

运行结果：
True

(4)、获取列表中的最大的元素和最小的元素。

• max(列表)
• min(列表)

print(max([1,24,56,7]))
print(max(['a','hj','uio','z']))
print(max([1,33,21,312]))

运行结果：
56
z
312

• 获取一个数字列表中的最大值

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

运行结果：
445
445

• count :获取指定元素在列表中出现的次数

print(numbers.count(-1))

运行结果：
0

• 列表.extend(序列)：将序列中的每一个元素，添加到列表中

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

运行结果：
['周星驰', '张家辉', '刘德华', '黄渤', '陈奕迅', '王祖贤']

• 列表.index(元素）：获取指定元素在指定列表中的索引（如果元素有多个，取第一个）

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

运行结果：
1

• 列表.reverse():反向列表中的元素(直接操作原列表，不会产生新的列表)

numbers = [1,2,3,4]
new_numbers = numbers.reverse()
print(numbers,new_numbers)

运行结果：
[4, 3, 2, 1] None

• .列表.sort():对列表元素进行排序

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

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

运行结果：
[1, 6, 42, 45, 90]
[90, 45, 42, 6, 1]

• 列表.clear()

numbers.clear()
# numbers = []  #效果同上
print(numbers)

运行结果：
[]

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

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

运行结果：
['张三', '李四']
# 注意：通过一个列表变量给另一个列表变量赋值的时候，赋的是地址。两个列表对元素进行操作的时候会相互影响。
# 想要避免这个问题就使用copy或者切片

二、元组

1、什么是元组

• 元组就是不可变的列表，列表中除了可变的操作以外，其它的操作都适用于元组。
• 元组值：a.使用（）将元素包含起来，多个元素之间用逗号隔开。例如：(1,2,'abc')
  b.元素的类型可以是任何类型。
• 改、增、删相关操作不能作用于元组。查 可以。

colors = ('red','green','yellow','purple')
# 1.查（和列表的查一模一样，没有任何区别）
print(colors[1])
print(colors[0:3])
print(colors[0::2])
for item in colors:
    print(item)

运行结果：
green
('red', 'green', 'yellow')
('red', 'yellow')
red
green
yellow
purple

2、len

print(len(colors))

运行结果：
4

3、in , not in

print('red' in colors)

运行结果：
True

4、+和*

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

运行结果：
(1, 2, 3, 4)
(1, 2, 1, 2)

5、元组补充：

（1）、获取元组的元素

names = ('name1','name2','name3')
x, y, z = names  #通过多个变量分表获取元组的元素（变量个数和元组元素个数一样）
print(x, y, z)

运行结果：name1 name2 name3

names = ('name1','name2','name2_2','name2_3','name3')
first,*midel,last = names     #通过变量名签加*可以把变量变成列表，获取多个元素
print(first, midel, last)

运行结果：name1 ['name2', 'name2_2', 'name2_3'] name3

*name1, name = names
print(name1,name)

运行结果：['name1', 'name2', 'name2_2', 'name2_3'] name3

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

运行结果：('name1', 'name2', 'name2_2', 'name2_3', 'name3')

三、字典

• 字典也是一直容器类型的数据类型（序列），存的数据是以键值对的形式出现的，字典中的元素全部都是键值对。
• 字典是可变的（可以增删改），但是是无序的（不能使用下标）。
• 键值对：键：值（key : value）键值对中key是形式，值才是真正要村的内容。
• 键：理论上可以是任何不可变的数据类型，但是实际开发的时候，一般使用字符串作为key
• 值：可以是任意数据类型数据

1、声明一个字典

• a.创建一个字典变量

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

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

运行结果：
<class 'dict'>
{'a': 1, 'b': 'abc', 10: [1, 2, 3], ('a', 'b'): 'abc'}

#字典里面的key是唯一的，后面的覆盖前面的
dict2 = {'a':1,'b':'abc','a':100}
print(dict2)

运行结果：
{'a': 100, 'b': 'abc'}

• b.将其他的数据类型转换成字典(了解)

dict3 = dict([(1,2),(2,3)])
print(dict3)

运行结果：
{1: 2, 2: 3}

2、字典的增删改查

• a.查
  （1） 获取字典的元素的值
  （2）字典获取元素的值是通过key来获取的

person = {'name':'路飞','age':17,'face':90}
print(person['name'],person['face'])
# print(person['aaa'])#如果key不存在，会报KeyError

"""
字典.get(key)
"""
print(person.get('name'))
print(person.get('aaa'))  #如果key不错在，返回none

运行结果：
路飞 90
路飞
None
"""
注意：如果key值确定存在，使用[]语法获取值。不确定key值是否存在才使用get方法获取值
"""

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

person['height'] = 1.8
print(person)

person['age'] = 18
print(person)

运行结果：
{'name': '路飞', 'age': 17, 'face': 90, 'height': 1.8}
{'name': '路飞', 'age': 18, 'face': 90, 'height': 1.8}

• c.删除:删除的是键值对
  del 字典[key] --->注意：key如果不存在会报错

del person['face']
print(person)

"""
字典.pop（key） --->会返回被删除的值
"""
age = person.pop('age')
print(person , age)

运行结果：
{'name': '路飞', 'age': 18, 'height': 1.8}

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,type(keys))
# 遍历获取每个key
for key in keys:
    print(key)
print(student_dict.values())
print(student_dict.items())

运行结果：
dict_keys(['name', 'study_id', 'scores']) <class 'dict_keys'>
name
study_id
scores
dict_values(['张三', 'py1805001', {'english': 60, 'math': 100}])
dict_items([('name', '张三'), ('study_id', 'py1805001'), ('scores', {'english': 60, 'math': 100})])

4.遍历字典

# a.直接遍历字典获取到的是所有的key(推荐使用，代码简单，cpu消耗少)

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

# b.遍历直接获取到key和value (不推荐使用)
for key,value in student_dict.items():
    print(key,value)

for value in student_dict.values():
    print(value)

运行结果：
name {'english': 60, 'math': 100}
study_id {'english': 60, 'math': 100}
scores {'english': 60, 'math': 100}
name 张三
study_id py1805001
scores {'english': 60, 'math': 100}
张三
py1805001
{'english': 60, 'math': 100}

5.列表中有字典、字典中有字典、字典中有列表

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

class1 = [{'name': '张三', 'age': '23', 'sex': '男', 'tel': '1563556662600'},
          {'name': '李四', 'age': '24', 'sex': '男', 'tel': '1563556262600'},
          {'name': '小明', 'age': '26', 'sex': '男', 'tel': '1563556562600'},]

class2 = {'name':'py1805',
          'address':'19-1',
          'sdudents':[
              {'name':'张三','age':'18'},
              {'name':'张三','age':'18'},
          ]
    }

6.其它操作

1.fromkeys()
dict.fromkeys(序列，value):创建一个新的字典，序列中的元素作为key,value作为值
"""
dict1 = {'a':1,'b':2}
new_dict = dict1.fromkeys('abc','100')
new_dict = dict1.fromkeys(range(10),'100')
new_dict = dict1.fromkeys(['abc','dcc','123'])
print(new_dict)

运行结果：
{'abc': None, 'dcc': None, '123': None}

2.in 
key in 字典：判断字典中是否存在指定的key
"""
dog_dict = {'color':'white','age':3,'type':'土狗'}
print('color' in dog_dict)  # 判断的是键是否存在
# print('white' in dog_dict)

True

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

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

运行结果：
{'1': 'aaa', '2': 'b', '3': 'bbb'}

四、集合

• 集合也是一种容器类型的数据类型（序列），数据放在{}中，多个之间只用逗号隔开：{1,2，'a'}
• 集合是无序的（不能通过索引去取值），可变（可以增删改），元素不能重复。
• 集合可以进行数字中集合相关的操作：判断是否包含，求交集、并集、差集、补集

1.怎么声明集合

"""
a.声明一个变量，赋一个集合值
"""
set1 = {1,2,3}
print(set1,type(set1))

运行结果：
{1, 2, 3} <class 'set'>

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

运行结果：
{'1', '2', 'b', '3', 'h', 'c', 'a'}
{32, 'hh', 12, 'abc'}
[32, 'hh', 12, 'abc']

2.增删改查

"""
a.查：遍历
注意：集合没有办法单独获取某一个元素
"""
for item in set2:
    print(item)

运行结果：
1
2
b
3
h
c
a

"""
b.增
"""
# 集合.add（元素）：在指定的集合中添加指定的元素。
set1 = {1,2,3}
set1.add(100)
print(set1)

#集合1.update(集合2)：将集合2中的元素添加到集合1中，自动去重
set1.update({'abc','ss'})
print(set1)


运行结果：
{1, 2, 3, 100}
{1, 2, 3, 100, 'ss', 'abc'}

"""
c.删
"""
# 集合.remove(元素)：在指定的集合中删除指定的元素。
set1.remove('ss')
print(set1)

# pop删除是随机删除一个
set1.pop()
print(set1)

运行结果：
{1, 2, 3, 100, 'abc'}
{2, 3, 100, 'abc'}

3.判断是否包含

• 集合1 >= 集合2 --->判断集合1中是否包含集合2（判断集合2中的所有元素是否都在稽核1中）
• 集合1 <= 集合2 --->判断集合2中是否包含集合1

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

运行结果：
True
False

4.数学的集合运算

""" 求并集：| """
print({1,2,3}|{2,3,4,5})

{1, 2, 3, 4, 5}

""" 求交集：& """
print({1,2,3} & {2,3,4,5})

{2, 3}

""" 求差集 ：-   """
print({1,2,3} - {2,3,4,5})

{1}

""" 求补集 ：^"""
print({1,2,3} ^ {2,3,4,5})

{1, 4, 5}

set1 = {1,2,3}
set1.clear()
print(set1,type(set1))

set() <class 'set'>

""" len:获取集合中元素的个数"""
print(len(set1))

0