数据类型 分为数字型和非数字型。
数字型包括整型，长整型，浮点型，复数型；
非数字型包括字符串，列表，元组和字典 ；
非数字型的共同点：都可以使用切片、链接（+）、重复（*）、取值（a[]）等相关运算;
非数字型的不同点：
字符串表示方式：str="hello,world"
Python 的字串列表有2种取值顺序:
从左到右索引默认0开始的，最大范围是字符串长度少1
从右到左索引默认-1开始的，最大范围是字符串开头
可以使用 [头下标:尾下标] 来截取相应的字符串。
其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。
[头下标:尾下标] 获取的子字符串包含头下标的字符，但不包括上边界。
截取方式相同：名称[头下标:尾下标]
1.列表（list）
列表用 "[ ]" 标识类似 C 语言中的数组。可以直接赋值。
列表表示方式：list=['hello',2,3,4,'world']
列表是 一个用list类定义的序列，包括创建、操作和处理列表的方法。
列表数据类型能存储一个有序的元素集合。列表中元素可以通过下标来访问。
（1）Python 中列表的大小时可变的可以按照需求增加、减小。
（2）一个列表可以包含相同类型元素、不同类型的元素。
（3）Python 中字符串和列表都是序列类型。一个字符串是一个字符序列，一个列表是任何元素序列。
(1) 查找
index()：返回指定数据所在位置的下标 。如果查找的数据不存在则报错。
count()：统计指定数据在当前列表中出现的次数。
len()：访问列表⻓度，即列表中数据的个数。
in：判断指定数据在某个列表序列，如果在返回True，否则返回False。
not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False。
#列表序列.index(数据, 开始位置下标, 结束位置下标)
name_list = ['Tom', 'Lily', 'Rose']
print(name_list.index('Lily', 0, 2)) # 1
print(name_list.count('Lily')) # 1
print(len(name_list)) # 3
print('Lily' not in name_list) # 结果：False
print('Lilys' not in name_list) # 结果：True
name = input('请输⼊您要搜索的名字：')
if name in name_list:
print(f'您输⼊的名字是{name}, 名字已经存在')
else:
print(f'您输⼊的名字是{name}, 名字不存在')
(2) 增加
append()：列表结尾追加数据。
extend()：列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表。
insert()：指定位置新增数据。
name_list = ['Tom', 'Lily', 'Rose']
name_list.append('xiaoming')
print(name_list) # 结果：['Tom', 'Lily', 'Rose', 'xiaoming']
name_list.append(['xiaoming', 'xiaohong'])
print(name_list) # 结果：['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]
name_list.extend('xiaoming')
print(name_list) # 结果：['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
name_list.extend(['xiaoming', 'xiaohong'])
print(name_list) # 结果：['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']
name_list.insert(1, 'xiaoming')
print(name_list) # 结果：['Tom', 'xiaoming', 'Lily', 'Rose']
(3) 删除
del ： 删除列表或删除指定数据。
pop()：删除指定下标的数据(默认为最后⼀个)，并返回该数据。
remove()：移除列表中某个数据的第⼀个匹配项。
clear()：清空列表。
name_list = ['Tom', 'Lily', 'Rose']
del name_list
print(name_list) # 结果：报错提示：name 'name_list' is not defined
del name_list[0]
print(name_list) # 结果：['Lily', 'Rose']
del_name = name_list.pop(1)
print(del_name) # 结果：Lily
print(name_list) # 结果：['Tom', 'Rose']
name_list.remove('Rose')
print(name_list) # 结果：['Tom', 'Lily']
name_list.clear()
print(name_list) # 结果： []
(4) 修改
reverse() ： 逆置
sort()：排序
copy()：复制
name_list = ['Tom', 'Lily', 'Rose']
name_list[0] = 'aaa'
print(name_list)# 结果：['aaa', 'Lily', 'Rose']
num_list = [1, 5, 2, 3, 6, 8]
num_list.reverse()
print(num_list) # 结果：[8, 6, 3, 2, 5, 1]
num_list = [1, 5, 2, 3, 6, 8]
num_list.sort()
print(num_list) # 结果：[1, 2, 3, 5, 6, 8]
name_list = ['Tom', 'Lily', 'Rose']
name_li2 = name_list.copy()
print(name_li2) # 结果：['Tom', 'Lily', 'Rose']
(5) 遍历
while遍历
name_list = ['Tom', 'Lily', 'Rose']
i = 0
while i < len(name_list):
print(name_list[i])
i += 1
for遍历
name_list = ['Tom', 'Lily', 'Rose']
for i in name_list:
print(i)
(6) 嵌套
谓列表嵌套指的就是⼀个列表⾥⾯包含了其他的⼦列表。
name_list = [['⼩明', '⼩红', '⼩绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四',
'王五']]
#如何查找到数据"李四"？
# 第⼀步：按下标查找到李四所在的列表
print(name_list[2])
# 第⼆步：从李四所在的列表⾥⾯，再按下标找到数据李四
print(name_list[2][1])
a=[] #声明一个空的列表
for i in range(0,10):
x=input()
a.append(x) #列表内填入相应的值
for i in range(0,10):
print(a[i])
a.sort() #调用内置函数，排序
a[2]=1 #直接进行赋值
for i in range(0,10):
print(a[i])
2.元组（tuple）
元组用 "( )" 标识。内部元素用逗号隔开。
# 多个数据元组
tt = (10, 20, 30)
# 单个数据元组
tt = (10,)
元组和列表类似，但元组中元素固定不变， 但是元组不能二次赋值，相当于只读列表。
当应用中存在不应该对列表数据进行修改的情况时，为了防止数据被恶意修改，应当使用元组类型来存储数据，防止数据被恶意的添加、删除、替换，并且元组比列表的效率更高。
1）元组中数据固定不可添加、修改、替换、重新排序。
2）元组是序列，针对序列的常见操作可以应用于元组。比如可以使用len、min、max、sum函数。
3）可以使用for循环遍历元组中元素，使用下标运算符访问元组中对应的有元素和元素段，可以使用IN和NOT IN运算判断一个元素是否在元组中。
4）一个元组包含着是一个固定的元素列表。
查找
index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index
⽅法相同。
count()：统计某个数据在当前元组出现的次数。
len()：统计元组中数据的个。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0]) # aa
print(tuple1.count('bb')) # 2
print(len(tuple1)) # 4
tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
print(tuple2[2]) # 访问到列表
tuple2[2][0] = 'aaaaa'
print(tuple2) # 结果：(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000 # 元组中是非法应用
list[2] = 1000 # 列表中是合法应用
t = () #空元组
t = (520,1314)
for i in t: #循环输出元组内的元素
print(i)
3.集合（set）
集合用 "{}" 标识。内部元素用逗号隔开。
集合与列表类似，可以使用他们存储一个元素集合。但是与列表不同，集合中的元素时不重复并且不是按照特定顺序放置的。
当应用程序不需要在意元素的顺序，使用一个集合来存储元素比列表效率会更高。
（1）创建集合使⽤ {} 或 set() ， 但是如果要创建空集合只能使⽤ set() ，因为 {} ⽤来创建空字典。
（2）集合中每个对象必须是哈希的
（3）集合是无序的，不能索引
（4）集合的元素是唯一的，若num={1，2，3，4，5，5，4，3，2，1} 重复的值会被忽略，结果为 num ={1,2,3,4,5}
(1) 增加
add()：追加数据。
update()： 追加的数据是序列。
ss = {10, 20}
ss.add(100)
ss.add(10)
print(s1) # {100, 10, 20}
s1.update(100) # 报错
s1.update([100, 200])
s1.update('abc')
print(s1) # {'a',100,200, 10,'b','c' ,20}
(2) 删除
remove()，删除集合中的指定数据，如果数据不存在则报错。
discard()，删除集合中的指定数据，如果数据不存在也不会报错。
pop()，随机删除集合中的某个数据，并返回这个数据。
s1 = {10, 20}
s1.remove(10)
print(s1)
s1.remove(10) # 报错
print(s1)
s2 = {10, 20}
s2.discard(10)
print(s2)
s2.discard(10) # 不报错
print(s2)
s3 = {10, 20, 30, 40, 50}
del_num = s3.pop()
print(del_num)
print(s3)
(3) 查找
in：判断数据在集合序列。
not in：判断数据不在集合序列。
s1 = {10, 20, 30, 40, 50}
print(10 in s1)
print(10 not in s1)
a_set = {1,2,3,4}
a_set.add(5) #添加一个元素
for i in a_set:
print(i)
a_set.discard(3) #删除掉一个元素
for i in a_set:
print(i)
4.字典（dict）
字典是一个存储键值对集合的容器对象，它通过使用关键字实现快速获取、删除和更新值。
字典用 "{ }" 标识。每一组用冒号连起来，然后各组用逗号隔开。
# 有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 空字典
dict2 = {}
dict3 = dict()
字典由索引 key 和它对应的值 value 组成。按照 dict[k]=v 的方式赋值。
字典能够通过键值对的形式精确查找数据，并且支持数据异构。
（1）能通过关键字快速获取、删除和更新值。
（2）字典可以包含类型相同和不同的元素。
（3）字典是无序的对象集合，不支持 索引， 分片。
（4）字典为可变类型。
(1) 增加
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1['name'] = 'Rose'
print(dict1) # 结果：{'name': 'Rose', 'age': 20, 'gender': '男'}
dict1['id'] = 110
print(dict1) # {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
(2) 删除
del() / del：删除字典或删除字典中指定键值对。
clear()：清空字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
del dict1['gender']
print(dict1) # 结果：{'name': 'Tom', 'age': 20}
dict1.clear()
print(dict1) # {}
(3) 查找
key值查找
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1['name']) # Tom
print(dict1['id']) # 报错
get()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.get('name')) # Tom
print(dict1.get('id', 110)) # 110
print(dict1.get('id')) # None
keys()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])
values()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values()) # dict_values(['Tom', 20, '男'])
items()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender','男')])
(4) 遍历
遍历字典的key
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1.keys():
print(key)
遍历字典的value
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for value in dict1.values():
print(value)
遍历字典的元素
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
print(item)
遍历字典的键值对
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
print(f'{key} = {value}')
5.公共操作
运算符
# 1. 字符串
str1 = 'aa'
str2 = 'bb'
str3 = str1 + str2
print(str3) # aabb
print('-' * 10) # ----------
# 2. 列表
list1 = [1, 2]
list2 = [10, 20]
list3 = list1 + list2
print(list3) # [1, 2, 10, 20]
list4= ['hello']
print(list4 * 4) # ['hello', 'hello', 'hello', 'hello']
# 3. 元组
t1 = (1, 2)
t2 = (10, 20)
t3 = t1 + t2
print(t3) # (10, 20, 100, 200)
t4 = ('world',)
print(t4 * 4) # ('world', 'world', 'world', 'world')
公共⽅法
# 1. 字符串
str1 = 'abcdefg'
del str1
print(str1)
str1 = 'abcdefg'
print(max(str1)) # g
print(min(str1)) # a
# 2. 列表
list1 = [10, 20, 30, 40]
del(list1[0])
print(list1) # [20, 30, 40]
list1 = [10, 20, 30, 40]
print(max(list1)) # 40
print(min(list1)) # 10
#range()⽣成的序列不包含end数字。
for i in range(1, 10, 1):
print(i) # 1 2 3 4 5 6 7 8 9
for i in range(1, 10, 2):
print(i) # 1 3 5 7 9
for i in range(10):
print(i) # 0 1 2 3 4 5 6 7 8 9
list1 = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(list1):
print(i)
for index, char in enumerate(list1, start=1):
print(f'下标是{index}, 对应的字符是{char}')
容器类型转换
tuple() 将某个序列转换成元组
list1 = [10, 20, 30, 40, 50, 20]
s1 = {100, 200, 300, 400, 500}
print(tuple(list1))
print(tuple(s1))
list() 将某个序列转换成列表
t1 = ('a', 'b', 'c', 'd', 'e')
s1 = {100, 200, 300, 400, 500}
print(list(t1))
print(list(s1))
set() 将某个序列转换成集合
list1 = [10, 20, 30, 40, 50, 20]
t1 = ('a', 'b', 'c', 'd', 'e')
print(set(list1))
print(set(t1))
list，tuple，set，dict区别总结图：