目录
一.序列
1.序列的切片：
2.关于序列的相加、相乘
3.检查某个元素是否存在于序列当中
4.计算序列的长度、最大、最小值、求和。
二、列表（list）
1.列表（list）的创建
2.列表（list）中的添加
3.列表（list）中的删除：
4.列表（list）中的修改：
6.其他一些用法
三.元组（tuple）
1.元组(tuple)的创建
2.元组（tuple）的删除
3.元组（tuple）的修改
4.查看元组（tuple）
5.元组（tuple）中其他一些操作方法。
四.字典（dict）
1.字典（dict）的创建
2.字典（dict）的添加与修改
3.字典（dict）的删除
4.字典（dict）的遍历
5.字典（dict）中的一些其他用法
一.序列
序列就是将一组值按一定顺序排列，每一个值就是一个元素。列表、元组、字典、集合、字符串，这些都是序列。
1.序列的切片：
（1）.索引
索引就是序列每个元素的下标，如：
list_1 =‘Hello word ！’
Hello word ！这些元素所对应的下标从左往右依次为：
H e l l o w o r d ！
0 1 2 3 4 5 6 7 8 9
而从右往左依次为：
H e l l o w o r d ！
-10 -9 -8 -7 -6 -5 -4 -3 -2 -1
下面这些数字就是索引，也叫下标，我们就可以通过索引来访问序列中某个元素。
例如：
list_1[2] >>>>>> 输出为：‘ e‘
为什么为‘e’而不是 ’l‘呢，因为list_1[2]中的；’2‘代表的是第二个元素，索引从左往右是从’0‘开始的。具体操作在切片中进行。
（2）.切片
name[start,end,step]
name：序列的名称
start： 切片开始的位置，不指定为0，默认从第一个元素开始，可以省略。
end： 切片结束的位置，不包括这个位置，不指定的话就是整个序列
step： 步长，就是切片隔几个元素切一次，不指定的话默认为1，可以省略。
（空格会算进去）
例如：
list_1 =‘Hello word ！’
print（a[:]）
>>>>>> 输出为 ‘Hello word ！ （因为都没指定所以就是整个序列第一个到最后一个元素）
print (a[1：5])
>>>>>> 输出为 ’ello‘ （要记住这个切片是左闭右开的，也就是包含左右的却不包含右边的）
print (a[2:10:2])
>>>>>> 输出为 ’lowr‘ （从第二个元素l到最后一个元素’！‘ 隔一个数取一次）
print（a[9]）
>>>>>> 输出为’d‘ （这个就是取第几个元素的值和上面区分开来二不是第8个元素’r‘）
2.关于序列的相加、相乘
（1）.支持类型相同的序列通过相加进行连接，里面元素的类型可以不同。类型不同的序列相加程序报错。
例如
a=’p‘
b=’i‘
c=’g‘
print（a+b+c)
>>>>>> 输出为：pig
（在字符串中还可以通过（’分隔符‘）.join（序列）将所有元素合并成一个新的字符串）
例如：
a='hello,word!'
print('*'.join(a))
>>>>>> 输出为：h*e*l*l*o*w*o*r*d*! (如果中间有空格也会添加’*‘，因为空格也是一个字符。）
（2）.相乘就是序列乘以一个数这个序列会被复制几次。
例如：
a='hello,word!'
print(a*3)
>>>>>> 输出为：’hello,word！ hello,word！ hello,word！‘
3.检查某个元素是否存在于序列当中
可以用‘in’
例如：
a='123456'
print('1' in a)
>>>>>> 输出为：'True' (如果不存在返回False)
同时对于字符串（str）、列表（list）、元组（tuple）、字典（dict）可以用”count“查询某个元素在这几个序列中的次数，如果没有返回0。
例如：
a=['cat','dog','bird','mouse','cat' ]
print(a.count('cat'))
>>>>>> 输出为：2 (在该列表当中‘cat’出现的次数是两次，count的意思是计数的意思，除了集合（set）不适用这种方法其他几个序列除了可以通过‘in’也可以通过‘count’的方法)
4.计算序列的长度、最大、最小值、求和。
求和只能用于序列中的元素都是数字。
len（序列）
min（序列）
max（序列）
例如：
a=['号','天','玩','新','顽' ] print(sum(a))
>>>>>> TypeError: unsupported operand type(s) for +: 'int' and 'str'
二、列表（list）
1.列表（list）的创建
方法1：
list_1 = [] print(type(list_1)) ""
这样就创建了一个空列表，输出我么可以得到list_1的类型为' list '，' [ ] '这种符号就是代表一个列表。
方法2:
#将字符串转换为一个列表
str_1 = 'Hello Python'
print('list_1:',list_1(str_1))
print('list_1的类型为：',type(list_1(str_1)))
#将元组转换为一个列表
tuple_1 = ('Hello','Python')
print('list_2:',list_2(tuple_1))
print('list_2的类型为：',type(list_2(tuple_1)))
#将字典转换为一个列表
dict_1 = {'Hello':'Python'}
print('list_3:',list_3(dict_1))
print('list_3的类型为：',type(list_3(dict_1)))
"""
list_1: ['H', 'e', 'l', 'l', 'o', ' ', 'P', 'y', 't', 'h', 'o', 'n']
list_1的类型为：
list_2: ['Hello', 'Python']
list_2的类型为：
list_3: ['Hello']
list_3的类型为：
进程已结束,退出代码0
"""
很明显可以通过' list '可以将字符串（str），元组（tuple），字典（dict）转换成列表。
以上就是关于列表的创建。
2.列表（list）中的添加
方法1：
通过使用 ' append ' 函数来往列表中添加元素
list_1 = ['H','E','L','L']
list_1.append('O')
print(list_1)
# 输出为 ['H', 'E', 'L', 'L', 'O']
通过 ' append '会在列表最后添加一个元素。
方法2：
使用' insert '将一个元素按照索引插入进列表
list_1 = ['H','E','L','L'] list_1.insert(4,'O') print(list_1) # 输出为 ['H', 'E', 'L', 'L', 'O']
insert（' 该位置填要插入列表中的索引（index） '，' 改位置为要插入的元素（element） '）
方法3：
' extend '将一个列表中的所有元素添加进另一个列表当中。
list_1 = ['H','E','L','L'] list_2 = ['P','y','t','h','o','n'] list_1.extend(list_2) print(list_1) #输出为：['H', 'E', 'L', 'L', 'P', 'y', 't', 'h', 'o', 'n']
（还可以通过' + '将多个列表拼接成一个新的列表，但一般不提倡这种方法）
3.列表（list）中的删除：
常用的几种方法：
方法1：
' del '，可以删除所有整个列表，也可以通过索引删除列表中的某个元素。
list_1 = ['P','Y','T','H','O','N']
del list_1[0] #删除索引为0的元素也就是'P'
print('删除P后：',list_1)
list_2 = ['H','E','L','L','O']
del list_2
print('删除后：',list_2)
# 输出为：删除P后： ['Y', 'T', 'H', 'O', 'N']
#'删除后：'
#NameError: name 'list_2' is not defined
方法2：
' remove '，移除列表中的某个元素。
list_1 = ['P','Y','T','H','O','N']
list_1.remove('P')
print(list_1)
#输出为：['Y', 'T', 'H', 'O', 'N']
方法3：
' pop （）'如果没定义默认删除最后一个元素，' ( ) '内可以指定要删除元素的索引从而删除该元素。
list_1 = ['P','Y','T','H','O','N']
list_1.pop('P')
print(list_1)
list_2 = ['H','E','L','L','O']
list_2.pop()
print(list_2)
"""输出为：['Y', 'T', 'H', 'O', 'N']
['H', 'E', 'L', 'L']"""
4.列表（list）中的修改：
通过索引进行修改
list_1 = ['P','Y','T','H','O','N'] list_1[0] = 123 print(list_1) #将索引为0的元素改为123 #输出为：[123, 'Y', 'T', 'H', 'O', 'N']
5.列表（list）中的查询：
通过' for '循环
list_1 = ['P','Y','T','H','O','N']
#第一种：
for i in list_1:
print(i)
print('*'*30)
#第二种：
for index,item in enumerate(list_1):
print('第{}个元素为{}'.format(index+1,item))
"""
输出为：
P
Y
T
H
O
N
******************************
第1个元素为P
第2个元素为Y
第3个元素为T
第4个元素为H
第5个元素为O
第6个元素为N
进程已结束,退出代码0
"""
6.其他一些用法
（1）' list_1.count '查询列表中某个元素出现的次数。
（2）' list_1.index '查询列表中某个元素的下标/索引。
（3）' list_1.sort '将的列表排序。
（4）'in' 和 'not in '判断某个元素是否存在于列表，存在返回True，不存在返回False。
list_1 = [10,True,15.7,6.8,85,0,10]
print(list_1.count(10)) # 查询10出现的次数
print(list_1.index(True)) # 查询True的索引
list_1.sort() # 将列表排序
print(list_1)
if 10 in list_1: # 判断10是否存在于列表
print('存在于列表')
else:
print('不存在于列表')
"""
输出为：
2
0
[0, True, 6.8, 10, 10, 15.7, 85]
存在于列表
"""
当使用' index '的时候如果有两个及以上的相同元素默认返回第一次出现元素的索引，如果没有找到就会报错。
使用' sort '的时候会默认为升序' reverse = False '，如果在list_1.sort( )中加入list_1.sort( reverse = True)则为降序排列。
三.元组（tuple）
元组（tuple）属于不可变序列所以它不支持添加，修改，删除元组（tuple）内单个元素。
1.元组(tuple)的创建
tuple_1 = ()
print(tuple_1)
print(type(tuple_1))
#通过'tuple'将列表（list）、字符串（str）、子弹（dict）转换成元组（tuple）
tuple_2 = tuple([1,2,3])
print(tuple_2)
print(type(tuple_2))
tuple_3 = tuple('我爱你！')
print(tuple_3)
print(type(tuple_3))
tuple_4 = tuple({'a':1,'b':2})
print(tuple_4)
print(type(tuple_4))
#输出为：
()
(1, 2, 3)
('我', '爱', '你', '！')
('a', 'b')
但在定义元组时要注意例如：
tuple_1 = ('Hello Python!')
print(type(tuple_1))
# 这样的其实是一个字符串必须要加个','
tuple_2 = ('Hello Python!',)
print(type(tuple_2))
# 括号可省但','不可省，不然还是一个字符串
tuple_3 = 'Hello Python!',
print(type(tuple_2))
"""输出为：
"""
2.元组（tuple）的删除
元组（tuple）是不可变序列，所以它不支持删除元组内单个元素，但可以删除整个元组（tuple），通过' del '来实现。
tuple_1 = ('Hello Python!')
del(tuple_1)
print(tuple_1)
#输出为：NameError: name 'tuple_1' is not defined
3.元组（tuple）的修改
如果需要修改元组只能重新赋值。
tuple_1 = ('Hello ')
tuple_1 = ('Hello Python!')
print('新元组为：',tuple_1)
"""
输出为：
新元组为：Hello Python!
"""
4.查看元组（tuple）
tuple_2 = ('Hello Python!','Hello Word!','你好python')
for i in tuple_2:
print('tuple_2中有：',i,'n')
print('第二个元素为：',tuple_2[1],'n')
print('第二个元素中的第一个元素是：',tuple_2[1][0])
"""
输出为：
tuple_2中有： Hello Python!
tuple_2中有： Hello Word!
tuple_2中有： 你好python
第二个元素为： Hello Word!
第二个元素中的第一个元素是： H
"""
5.元组（tuple）中其他一些操作方法。
（1）' index '查看元组某个元素的下标。
（2）' count '查看元组某个元素出现次数。
tuple_1 = (1,2,3,1,4,5)
#查看元素为2的下标
print('2的下标为：',tuple_1.index(2))
#查看1出现的次数
print('1出现的次数为：',tuple_1.count
"""
输出为：
2的下标为： 1
1出现的次数为： 2
"""
四.字典（dict）
1.字典（dict）的创建
#第一种
dict_1 = { }
#第二种
dict_2 = dict()
#第三种
dict_3 = dict(zip(list1,list2))
#第四种
dict_1 = dict.fromkeys(list_1)
#第一种
dict_1 = { }
#第二种
dict_2 = dict()
#第三种
dict_3 = dict(zip(list1,list2))
#第四种
dict_1 = dict.fromkeys(list_1)
第三种通过映射函数创建字典，' list1'是用来作为字典的键（key）可以是列表，元组，字符串，' list2'用来作为字典的值（value）可以是列表，元组，字符串。
第四种通过' fromkeys '创建值为空的列表，' list1'可以是列表，元组，字符串。
a = ('a','b','c','d')
b = [1,2,3,4]
c = '我爱死你'
dict_1 = dict(zip(a,b))
dict_2 = dict(zip(c,a))
print('当键为元组，值为列表时：',dict_1)
print('当键为字符串，值为元组时：',dict_2)
"""
输出为：
当键为元组，值为列表时： {'a': 1, 'b': 2, 'c': 3, 'd': 4}
当键为字符串，值为元组时： {'我': 'a', '爱': 'b', '死': 'c', '你': 'd'}
"""
2.字典（dict）的添加与修改
（1） dict_1 [key] = value
如果键（key）已经存在那么就会修改上一个键（key）的值（value），不存在就会添加。
（2）dict_1.setdefault( ):
如果键（key）不存在字典（dict）当中。' dict_1 '中就会添加键并将值(value)设为默认值' None '。当键（key）存在字典（dict），就会返回该键（key）的值（value）。
dict_1 = {'a':1,'b':2,'c':3,'d':4}
#当键不存在字典
dict_1.setdefault('e',5)
print('当键不存在字典：',dict_1)
#当键存在字典
print('当键存在字典该键的值为：',dict_1.setdefault('a'))
"""
输出为:
当键不存在字典： {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e':5}
当键存在字典该键的值为： 1
"""
3.字典（dict）的删除
字典种的几种删除的方法：
（1）' del '可以删除单个键值，但如果要删除的键不存在会报错。也可以删除整个字典，字典将不存在。
（2）' clear '可以清空字典中的所有键值对，字典还存在。
（3）' pop '通过键进行删除。
(4) ' popitem '不需要指定，删除最后一个。
dict_1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# 删除字典键为'a'
del dict_1['a']
print('用del删除一个元素：',dict_1)
#删除整个字典
del dict_1
dict_2 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
#清空字典中的所有键值对
dict_2.clear()
print('通过clear清空字典：',dict_2)
dict_3 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
#使用pop需要指定键
dict_3.pop('d')
print('用pop方法:',dict_3)
#使用popitem不需要指定，默认删除最后一个
dict_3.popitem()
print('用pop方法:',dict_3)
"""
输出为：
用del删除一个元素： {'b': 2, 'c': 3, 'd': 4}
通过clear清空字典： {}
用pop方法: {'a': 1, 'b': 2, 'c': 3}
用popitem方法: {'a': 1, 'b': 2}
进程已结束,退出代码0
"""
4.字典（dict）的遍历
dict_1 = {'a':1,'b':2,'c':3,'d':3}
for i in dict_1:
print(i,'n')
for key,value in dict_1.items():
print(key,value)
"""
输出为：
a
b
c
d
a 1
b 2
c 3
d 3
"""
5.字典（dict）中的一些其他用法
（1） dict_1.get(key) ：
与'dict_1.setdefault( ) ' 有点类似获取键（key）的值（value），当要查找的键（key）不存在默认返回 'None'。可以在' key '后面指定一个返回值。存在时返回该键（key）的值（value）。
（2）dicy_1.update(dict_2)：
把'dict_2'中的值更新到'dicy_1'当中去。
(3) dict_1.keys（） 与 dict_1.values（）:
分别获取键（key）和值（value）
dict_1 = {'a':1,'b':2,'c':3,'d':4}
#查找键
print('该键的值为：',dict_1.get('b'))
#字典的更新
dict_2 = {'e':5,'f':6}
dict_1.update(dict_2)
print(dict_1)
#获取键和值
print('dict_1的键为',dict_1.keys())
print('dict_1的值为',dict_1.values())
"""
输出为：
该键的值为： 2
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
dict_1的键为 dict_keys(['a', 'b', 'c', 'd', 'e', 'f'])
dict_1的值为 dict_values([1, 2, 3, 4, 5, 6])
"""
