基本数据类型及内置方法
列表
用途：用于存一个或者多个不同类型的值
定义方法：通过中括号存值，每个值之间通过逗号进行分隔
使用方法：
优先掌握的知识点：
1、索引取值（正反都可以），不仅可以取还可以存
l1 = [1, 2, 3, 4,5]
print(l1[2])
l1[2] = 222
print(l1)
3
[1, 2, 222, 4, 5]
2、索引切片
l1 = [1, 2, 3, 4,5]
print(l1[1:4])
[2, 3, 4]
3：append():追加值，只能添加到列表的最后一位，一次性只能添加一个值
l1 = [1, 2, 3, 4, 5]
l1.append(10000)
print(l1)
l1.append([9, 0])
print(l1)
[1, 2, 3, 4, 5, 10000]
[1, 2, 3, 4, 5, 10000, [9, 0]]
4、insert（）：插入值，通过索引指定插入的位置
l1 = [1, 2, 3, 4, 5]
l1.insert(3,999)
print(l1)
[1, 2, 3, 999, 4, 5]
5、extend（）
l1 = [1, 2, 3, 4, 5]
l1.extend([6,7,8])
print(l1)
[1, 2, 3, 4, 5, 6, 7, 8]
6、remove：指定值删除，比较彻底
l1 = [1, 2, 3, 4, 5]
l1.remove(1)
print(l1)
[2, 3, 4, 5]
7、pop（）：不传值，默认从最后开始删，指定索引删值，pop是有返回值的
l1 = [1, 2, 3, 4, 5]
val = l1.pop(2)
print(l1)
print(val)
[1, 2, 4, 5]
3
列表的内置方法：
count:统计当前列表内指定元素的个数
l1 = ['sean', 'egon', 'tank', 'sean']
print(l1.count('sean'))
2
index：获取当前指定元素的索引值，还可以指定查找范围
l1 = ['sean', 'egon', 'tank', 'sean']
print(l1.index('sean',1,4))
3
sort：排序，在原列表上进行排序操作
l1 = ['sean', 'egon', 'tank', 'sean']
l2 = [2, 1, 4, 6, 8, 3, 5, 6]
l2.sort(reverse=True)
print(l2)
l1.sort()
print(l1)
l3 = sorted(l2,) # python的内置函数，在排序时生成了一个新列表，原数据不变
print(l3)
[8, 6, 6, 5, 4, 3, 2, 1]
['egon', 'sean', 'sean', 'tank']
[1, 2, 3, 4, 5, 6, 6, 8]
clear()：清空列表数据
l3=[1, 2, 3, 4, 5, 6, 6, 8]
l3.clear()
print(l3)
[]
队列：先进先出
l1 = []
l1.append(1)
l1.append(2)
l1.append(3)
print(l1)
l1.pop(0)
print(l1)
l1.pop(0)
l1.pop(0)
print(l1)
[1, 2, 3]
[2, 3]
[]
堆栈：先进后出
l1 = []
l1.append(1)
l1.append(2)
l1.append(3)
print(l1)
l1.pop()
print(l1)
l1.pop()
print(l1)
l1.pop()
print(l1)
[1, 2, 3]
[1, 2]
[1]
[]
元组的基本方法
用途：存储多个不同类型的值（不能存可变类型）
定义方式：用过小括号存储数据，数据与数据之间通过逗号分隔，（值不能被改变）
#定义容器类型的时候，如果里面只有一个值，在值得后面加上一个逗号
#在元组中如果不加，就是字符串
t1 = ('a', 'b', 'c', 'a') # t1 = tuple(('a','b'))
print(t1)
print(type(t1))
('a', 'b', 'c', 'a')
<class 'tuple'>
常用方法：
1、索引取值（正取，反取）
2、索引切片
3、成员运算in，not in
4、len()
t1 = ('a', 'b', 'c', 'a')
print(t1[0:2])
print(t1.count('a'))
print(t1.index('a',1))
('a', 'b')
2
3
类型总结：
有序or无序：有索引，有序
可变or不可变：不可变
存一个值or存多个值：存多个值
字典（dict）基本方法
用途：
定义方式：通过大括号来存储数据，通过key：value来定义键值对数据，每个键值对中间通过逗号分隔
key：一定是一个不可变类型
value：可以是任意类型
d1 = {(1,2):[1,2]}
字典的三种定义方式：
1、
d1 = {'name':'egon', 'age':84}
2、
d2 = dict({'name':'egon'})
3、
zip:
l1 = ['name', "age"]
l2 = ['egon',18]
z1 = zip(l1,l2)
print(dict(z1))
{'name': 'egon', 'age': 18}
常用方法：
1、优先掌握的
1:按照key：value映射关系取值（可存可取）
2：成员运算in，not in #默认判断key
3：len() #获取当前字典中键值对的个数
d1 = {'name': 'egon', 'age': 73}
print(d1['name'])
print(d1['age'])
d1['name'] = 'tank'
d1['gender'] = 'male'
print(d1)
print('egon' in d1)
egon
73
{'name': 'tank', 'age': 73, 'gender': 'male'}
False
内置方法
get：获取直指定key的值，如果值不存在，默认返回None，可以通过第二个参数修改默认返回的内容
d1 = {'name': 'egon', 'age': 73}
print(d1.get('gender'))
print(d1.get('gender','male'))
None
male
key、values、keys
d1 = {'name': 'egon', 'age': 73}
print(d1.keys()) # 返回所有的key
print(d1.values()) # 返回所有的值
print(d1.items()) # 返回所有的键值对，返回值是列表套元组，每一个键值对都是存在元组
dict_keys(['name', 'age'])
dict_values(['egon', 73])
dict_items([('name', 'egon'), ('age', 73)])
d1 = {'name': 'egon', 'age': 73}
for key in d1.keys():
print(key)
for value in d1.values():
print(value)
for key,value in d1.items():
print(key,value)
key,value = ("name",'age')
name
age
egon
73
name egon
age 73
pop：删除：指定key进行删除，有返回值，返回为对应的value
d1 = {'name': 'egon', 'age': 73}
a = d1.pop('name')
print(d1)
print(a)
{'age': 73}
egon
popitem()：随机弹出一个键值对，有返回值，返回只是一个元组
d1 = {'name':'egon', 'age': 73,'gender':'male','a':"1"}
d1.popitem()
print(d1)
{'name': 'egon', 'age': 73, 'gender': 'male'}
update：用新字典替换旧字典
d1 = {'name':'egon', 'age': 73,'gender':'male','a':"1"}
d1.update({"b":'2'})
print(d1)
d1.update({'name':'tank'})
print(d1)
{'name': 'egon', 'age': 73, 'gender': 'male', 'a': '1', 'b': '2'}
{'name': 'tank', 'age': 73, 'gender': 'male', 'a': '1', 'b': '2'}
fromkeys:生成一个新字典，第一个参数（列表），它会以第一个参数中各个元素为key，以第二个参数为值，组成一个新字典
print(dict.fromkeys([1,2,3],['ke','k1']))
{1: ['ke', 'k1'], 2: ['ke', 'k1'], 3: ['ke', 'k1']}
setdefault：key不存在新增键值对，有返回值，返回新增value，key存在返回对应的value
d1 = {'name':'egon', 'age': 73,'gender':'male','a':"1"}
print(d1.setdefault('name',1))
print(d1)
egon
{'name': 'egon', 'age': 73, 'gender': 'male', 'a': '1'}
字典类型总结：
有序or无序：无序
可变or不可变：可变类型
存一个值or存多个值：存多个值
集合基本方法
用途：去重，关系运算
定义方式：通过大括号存储数据，每个元素通过逗号分隔
定义空集合：必须使用set()来定义
l1 = []
s1 = ""
d1 = {}
ss1 = set()
合集：|
交集：&
差集：-
对称差集：^
1、集合中不可能出现两个相同的元素
python_student = {'egon', 'jason', 'tank', 'owen', 'egon'}
linux_student = {'frank', 'alex', 'egon'}
go_student = {'egon'}
print(python_student)
{'owen', 'tank', 'egon', 'jason'}
python_student = {'egon', 'jason', 'tank', 'owen', 'egon'}
linux_student = {'frank', 'alex', 'egon'}
go_student = {'egon'}
print(python_student | linux_student)
print(python_student & linux_student)
print(python_student - linux_student)
print(linux_student - python_student)
print(python_student ^ linux_student)
print(python_student > go_student)
print(python_student < linux_student)
{'frank', 'tank', 'owen', 'alex', 'jason', 'egon'}
{'egon'}
{'jason', 'tank', 'owen'}
{'alex', 'frank'}
{'tank', 'owen', 'alex', 'frank', 'jason'}
True
False
l1 = [1, 2, 3, 1, 2, 9, 1, 5, 6, 7]
print(l1)
s1 = set(l1)
print(s1)
print(type(s1))
l2 = list(s1)
print(l2)
print(type(l2))
[1, 2, 3, 1, 2, 9, 1, 5, 6, 7]
{1, 2, 3, 5, 6, 7, 9}
<class 'set'>
[1, 2, 3, 5, 6, 7, 9]
<class 'list'>
python_student = {'egon', 'jason', 'tank', 'owen', 'egon'}
for i in python_student:
print(i)
egon
owen
tank
jason
集合的类型总结
有序or无序：无序
可变or不可变：不可变
存一个值or存多个值：存多个值
基本数据类型总结
存一个:整型、浮点型、字符串
存多个值：列表、元组、字典、集合
可变or不可变： 可变：；列表，字典 不可变：整型、浮点型、字符串、元组、集合
有序or无序： 有序：字符串、列表、元组
无序：字典、集合
占用空间： 字典 列表 元组 集合 字符串 数字类型