操作（增，删，查，改）

列表

1.修改列表元素

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

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

输出：
['周星驰', '张家辉', '黄渤', '陈奕迅']

2. 列表其他操作

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

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

输出：6

2.列表1+列表2：让列表1和列表2的元素组合起来形成一个新的列表

new_names = names +['eric','ella']
print(new_names)

输出：
['周星驰', '张家辉', '黄渤', '陈奕迅','eric','ella']

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

print([1,2]*3)

输出：1,2,1,2,1,2

4.in,not in操作： 元素 in 列表：判断指定的元素是否在指定的列表中

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

输出:False

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

"""
max(list)
min(list)
"""

print(max([1,2,3,56]))
print(max(['a','hj','z','uio']))
print(min([1,3,4,4,5,5,6,6,6]))

输出;
56
z
1

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

numbers = [1,2,3,4,4,5,5,6,66,6]
max1 = numbers[1]
for x in numbers:
    if x > max1:
        max1 = x
print(max1)

输出：
66

4.其他方法

1.统计列表中某一个元素出现的次数： list.count(元素)

print(numbers.count(1))

2.list.extend(序列)：将序列中的每一个元素添加进列表中

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

3.list.index(元素)：获取指点元素在列表中的索引

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

4.list.reverse():反向列表中的元素(直接操作原数据)

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

5.list.sort():对列元素进行排序(默认是递增-升序)

numbers = [1,4,2,3]
numbers.sort() #升序
print(numbers)
numbers.sort(reverse=True) #降序
print(numbers)

6.list.clear():清空列表里面的元素 相当于 list=null或者

list=[]
numbers.clear()
print(numbers)

7.list.copy():将列表中的元素全部拷贝一份创建一个新的列表(赋值的时候地址不变，list.copy()地址改变)

names = ['张三','li']
new_names = names
new_names1 = names[:]
print(new_names,new_names1)

注意: 通过一个列表给另一个列表变量赋值的时候，赋的是地址；两个列表对元素进行操作的时候会相互影响。
想要避免这个问题就要使用copy或者切片

元组

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

元组值;a.使用（）将元素包含起来，多个元素之间用逗号隔开，比如：（1,2，'abc'）
b.元素的类型可以是任何类型

2.增，删，改相关操作不能作用于元组。查可以
'''
clors = ('red','green','yellow','purple')

1.查（和列表一样）

print(clors[1])
print(clors[0:3])
print(clors[0:0:2])
for item in clors:
    print(item)

2. len

print(len(clors))

3. in,not in

print('red' in clors)

4. +, *

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

5.元组补充

'''1.获取元组的元素'''

names = ('names1','names2','names3')
x, y ,z= names #通过多个变量获取元组的元素（变量个数和元素个数一样）
print(x,y)

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

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

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

字典

"""
字典也是一个容器类型的数据类型（序列）’寻得数据是以键值对的形式出现的，字典中的元素全部都是键值对
字典是可变的（可以增删改），但是是无序的（不能用下标）
键是唯一的

键值对：键:值(key:value):键值对中key是形式，值才是真正要存的内容
键理论上是任何不可变的数据类型，但实际开发的时候一般是使用字符串
值：可以是任何类型数据
"""#

1. 声明一个字典

'''a.创建一个空的字典'''

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

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

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

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

2,字典的增，删，改，查

'''
a.查：获取字典的元素
字典获取元素的值是通过key获取的
字典[key]
'''

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

'''
字典.get(key)
'''

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

'''
注意：如果key确定存在，使用[]语法取获取，不确定key值是否存在才使用get方法获取
'''

'''
b.增加元素\修改元素
通过key获取字典元素，然后赋值。当key存在的时候，就是修改元素的值，不存在的时候，就是增加键值对
'''

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

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

'''
c.删除 :删除的都是键值对
del 字典[key]   #(python中什么都可以删)
字典.pop(key)   #会返回被删除的键值对对应的值
'''
del person['face']
print(person)

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

3.相关的数组的属性

'''
字典.keys: 获取字典key,返回值类类型时dict_keys,但是可以把它当成列表来使用
字所有的典.values: 获取字典所有的值（value）
字典.items: 将字典中所有的键值对转换成一个一个的元组，key作为元组的第一个元素。value最为第二个人元素
'''

student_dict = {'name':'zhangsan','id':2,'scores':{'english':60,'mach':32}}
keys = student_dict.keys()
print(keys,type(keys))
# 遍历获取每一个key
for key in keys:
    print(key)

print(student_dict.values())

print(student_dict.items())

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)

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

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

students = [ {'name':'路飞','age':23,'sex':'男','tel':'122334'},
           {'name':'李四','age':25,'sex':'男','tel':'1278334'},
           {'name':'飞','age':83,'sex':'男','tel':'12290334'}
           ]
#xinxi = {'name':input('name:'),'xinbie:':input('xinbie:','age1':input('age')}

class1 = {
    'name':'python1805',
    'address':'19-1',
    'students':[
           {'name':'路飞','age':23,'sex':'男','tel':'122334'},
           {'name':'李四','age':25,'sex':'男','tel':'1278334'},
           {'name':'飞','age':83,'sex':'男','tel':'12290334'}]
}

6,其他操作

'''
1.fromkeys()
dict.fromkey(序列,value) :创建一个新的字典，序列中的元素作为key、value

'''

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

'''

2. in
   key in 字典：判断key是否在字典中
   '''

dog_dict ={'color':'yello'}
print('color' in dog_dict)
print('while' in dog_dict)

'''
3 . update
字典1.update(字典2) ： 使用字典2的键值对取更新字典1中的键值对，如果字典2中对应键值对不在字典1中就添加，没有就更新
'''

dict1 = {'clor':'yello'}
dict1.update({'clor':'green'})
dict1.update({'len':'133'})
print(dict1)

元组

"""
集合 set
集合也是一种容器类型的数据类型（序列）；数据放在{}，多个之间用逗号隔开;{1,2,3,a}
集合是无序的（不能通过索引取取值），可变（可以增删改），元素不能重复

集合可以进行数学中的集合操作，判断是否包含，求交集、并集、差集、补集
"""

1.怎么声明集合

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

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

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

set2 = set('abc123') #将其他的数据转换成集合，并且自带去重功能
print(set2)

set3 = set([12, 'adc', 'hh', 32])
print(set3)
print(list(set3))

2.增删改查

'''
a. 查：遍历
注意;集合么有办法单独获取某一个元素（无序）
'''

for item in set2:
    print(item)

'''
b.增
'''
集合.add(元素)：在指定的集合中添加指定的元素

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

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

set1.update({1,3,4,5})
print(set1)

'''
c.删除
'''
集合.remove(元素) ：在指定的集合中删除指定的元素

set1.remove(5)
print(set1)

pop删除是随机删除一个

set1.pop()
print(set1)

3, 判断是否包含
'''
集合1>=集合2 --判断集合1中是否包含集合2(判断集合2中的所有元素是否搜子啊集合1里面)
集合1<=集合2 --判断集合2中是否包含集合1
'''

print({1,2,3,4}>={1})
print({1,2,3,4}>={1,5})

print({1,2,3,4}<={1})
print({1,2}<={1,234,5,2})

4,数学的集合运算

'''
求并集：|
'''

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

'''求交集：&'''

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

'''求差集'：-'''

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

'''补集: ^ '''

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

5.其他方法

'''clear：清空集合'''

set1.clear()
print(set1)

'''len:获取集合中的元素'''

print(len(set1))