一.列表常用方法

l = [1,2,3,4,5,6,7,]
count（）
res = l.count（8）
print（res）

clear（）
print（l）
res = l.clear（）
print（l）
print（res）
print（id（l））
l.reverse（） # 将列表反转
print（id（l））
print（l）

l.sort（） 排序 默认情况下是从小到大（升序）
l1 = [43,1,6,7,99]
l1.sort（reverse=True） # 可以通过制定参数来修改默认的排序规则（降序）
print（11）

"""
存多个值
有序
可变
"""

队列 先进先出
l1 = [ ]
先进
l1.append（'first'）
l1.append（'second'）
l1.append（'third'）
先出
print（l1.pop（0））
print（l1.pop（0））
print（l1.pop（0））

堆栈 先进后出
先进
l1.append（'first'）
l1.append（'second'）
l1.append（'third'）
后出
print（l1.pop（））
print（l1.pop（））
print（l1.pop（））

二.元组及内置方法

 

作用：能够存储多个元素，元素与元素之间逗号隔开 元素可以是任意类型，元组不能被修改
定义：与列表类型比，就是[ ]换成（）
age =（11,22,33,44,55） 本质age = tuple（（11,22,33,44,55））

优先掌握的操作：
1.按索引取值（正向取+反向取）：只能取
t = （1,2,3,'a','b',[1,2,3]）
print（t[0]）
t[1] = 'hahah' 报错
t[-1] = 'hhahah' 报错
t[-1][0] = 'waoh' (1, 2, 3, 'a', 'b', ['waoh', 2, 3])

2.切片（顾头不顾尾，步长）
print（t[::2]） (1, 3, 'b')

3.长度
print（len（t）） 6

4.成员运算in和not in
print（'a' in t） True

5.循环
for i in t:
print（i）

print（t.count（'a'））
print（t.index（'xxx'）

t = （1,2,3,'a','b',[1,2,3]） # tuple（（1,2,3,'a','b',[1,2,3]））
print（type（t）） # <class 'tuple'>
t1 = tuple（1） # 报错 必须传容器类型
n = （'a'）
n1 =（1）
print（type（n），type（n1） # <class 'str'> <class 'int'>
在定义容器类型的时候，哪怕内部只有一个元素，你也要用逗号隔开 区分一下 ********

能存多个值
有序
不可变

t2 = （1,2,3,4，[1,2]）
print（id（t2））
t2[-1].append（666）
print（t2）
print（id（t2））

三.字典及内置方法

作用：能存储多组 key：value键值对 key是对value的描述 key通常情况下都是字符串
# 其实这个key只能是不可变类型，value可以是任意数据类型

定义：
d = {'name':'tzz','password':123} # d = dict（{'name':'tzz','password':123}）
d1 = {1:'1',0:'0',1.11:'1.11',(1,2):'到底能不能呢？'}
print(d1[1.11])
print(type(d1))
print(d1[(1,2)])

d2 = {'name':'tzz','name':'zzt','name':'ttz','password':'123'}
强调：字典的key是不能重复的 要唯一标识一条数据
如果重复了 只会按照最后一组重复的键值对存储
print（len（d2））
print（d2）

优先掌握的操作
1.按key存取值 可存可取
d3 = {'name':'tzz','password':'123'}
print（id（d3））
print（d3['name']）
d3['name'] = 'tzt'
d3['name'] = 'ttt'
d3['name'] = 'ttz'
d3['name'] = 'zzt'

d3['age'] = 18 # 赋值语句当key不存在打的情况下，会自动新增一个键值对 **********
print（d3，id（d3））

2.长度len（） 统计的键值对的个数

3.成员运算in和not in 对于字典来说只能判断key值
d3 = {'name':'tzz','password':'123'}
print（'123' in d3）
print（'name' in d3）

4.删除
d3 = {'name':'tzz','password':'123'}
del d3['name']
print（d3）
res = d3.pop（'name'） # 弹出仅仅是value
res = d3.pop（'age'） # 当键不存在的时候直接报错
print（res）
print（d3）
d3.clear（）
print（d3）

定义字典的三种方式
掌握
d1 = {'name':'tzz','password':'123'}

掌握
d2 = dict（name = 'tzz',password = 123,age = 18）******
print（d2，type（d2））

了解即可
l = [
['name','tzz'],
['age',18],
['hobby','read']
]
d = { }
for i in l： # ['name','tzz'],['age',18]...
for k,v in l: # ['name','tzz'],['age','18']...
# d[i[0]] = i[1]
d[k] = v
print（d）
d3 = dict（l）
print（d3）

5.键keys（），值values（），键值对items（）
d1 = {'name':'tzz','password':123}
print（d1.keys（）） # dict_keys（['name','password']）
for k in d1.keys（）：
print（k）
print（d1.values（）） # dict_values（['tzz',123） 看作一个列表

print（d1.values（）） # dict_items（[（'name','tzz'）,（'password',123）]）
看成是列表套元组，元组的第一个元素是字典的key 第二个元素是字典的value

get（） 根绝key获取value *********************
d1 = {'name':'tzz','password':123}
print（d1['name']）
print（d1['age']）
print（d1.get（'name','你给我的name在字典的key中'））
res = d1.get（'age'） # 当字典的的key不存在的情况 不报错 返回None
res1 = d1.get（'xxx','你给我的age在字典的key中'） # 当字典的key不存在的情况下 不报错 返回None
# get 可以传第二个参数。当你的key不存在的情况下，返回第二个你写好的参数信息
print（res1）
print（d1.get（'xxx','asdsad'）） 第二个参数不写的话 当key不存在的情况下返回None，写了就返回写了内容

dict.fromkey（） 快速创建一个字典
l1 = ['name','password','age','hobby']
print（dict.fromkeys（11,123））

dict.popitem()
print（d1.popitem（）） # 尾部以元组的形式弹出键值对

dict.setdefault（）
d1 = {'name':'tzz','password':123}
res1 = d1.setdefault（'name','xxoo'） # 当键存在的情况下，不修改值，并且将原先key对应值返回给你
print（d1，res1）
res2 = d1.setdefault（'age',18） # 当键不存在的情况下，新增一个键值对，并且将新增的键值对的值返回给你
print（d1，res2）

dict.updata（）
d1 = {'name':'tzz','password':123}
d2 = {"age":18}
# d1.updata(d2)
d1['age'] = 18
d1.updata（age = 666）
print（d1）

6.循环
d1 = {'name':'tzz','password':123}
for i in d1:
print（i）

存多个值
无序
可变

四.集合及内置方法

pythons = ['jason','nick','tank',egon','kevin','owen','alex']
linux = ['frank','jerry','tank',egon','alex']

for name in pythons:
if name in linux:
print（name）
群体之间做比较，不涉及单个元素

集合 关系运算 去重

作用：去重，关系运算
定义：
s = {1,2,3,4,5,6} # <class 'set'> # s = set（）
print（type（s））

s1 = set（）
print（type（s1）） # 注意在定义空集合的只能用关键字set

x = { } # <class 'dict'> 如果你仅仅只写了一个大括号 namepython默认将它当做字典类型
print（type（x））

t = （） # <class 'tuple'>
print（type（t））

d = {[1,2]:'name'}
定义集合：
集合：可以包含多个元素，用逗号分割

集合的元素遵循三个原则：
1：每个元素必须是不可变类型
可变：不可hash
不可变：可hash
s = {1,2,3,4,5,6,'a',（1,2）} # 报错
s = {1,2,3,4,5,6,'a',（1,2），{"name":"tzz"}} # 报错

2.没有重复的元素
s = {1,2,2,2,2,2,2,2,2,2,3,4,4,4,4,4,5}
print（s） # 自动将重复的元素去除

3.无序
s = {1,2,3,4,5,6}
print（s[1]）

注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

优先掌握的操作：
1.长度 len
s = {1,2,3,4}
print（len（s））
2.成员运算in和not in
3.| 合集
4.& 交集
5.-差集
6.^对称差集
7.==
s = {1,2,3}
s1 = {3,1,2}

8.父集：>,>=
s = {1,2,3,4,55}
s2 = {1,2,666}
"""
issubset（）
issuperset（）
"""

print（s >= s2） # s是否包含s2
9.子集：<,<=

pythons = ['jason','nick','tank',egon','kevin','owen','alex']
linux = ['frank','jerry','tank',egon','alex']
既报名python也报名linux的学生姓名
print（python & linux） # 交集

只报名python的学生姓名
print（pythons - linux）

只报名linux的学生姓名
print（linux - pythons）

没有同时报名两门课程的学生姓名
print（pythons ^ linux） # 对称差集

取出所有报名了名的学生姓名
print（python | linux）

s = {1,2,3,4,5}
print（s.add（666））
print（s.add（（1,2,3,4,））） # 将容器类型也当成一个元素传入
s.
print（s.remove（1））
print（s）
print（s.discard（888888888））
print（s）

五.python数据类型总结

int
float
str
list
dict
bool
tuple
set

可变：list dict set
不可变：int float str tuple bool