内置方法

列表常用方法

定义：[]内可以有多个任意类型的值，逗号分隔

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,6,1,7,99]

l1.sort(reverse=True)  # 可以通过指定参数来修改默认的拍讯规则(降序)

print(l1)

队列   先进先出

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))

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‘>

View Code

在定义容器类型的时候，哪怕内部只有一个元素，你也要用逗号隔开 区分一下（******）

"""

优先掌握的操作：

1、按索引取值(正向取+反向取)：只能取

t = (1, 2, 3, ‘a‘, ‘b‘, [1, 2, 3])

print(t[0])

t[1] = ‘hahah‘

t[-1] = ‘hahaha‘

t[-1][0] = ‘我改了‘

print(t)

 

del t[0]

print(t)

View Code

2、切片(顾头不顾尾，步长)

print(t[::2])

3、长度

print(len(t))

4、成员运算in和not in

print(‘a‘ in t)

5、循环

for i in t:

     print(i)

print(t.count(‘a‘))

print(t.index(‘xxx‘))

能存多个值

有序

不可变

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‘:‘jason‘,‘password‘:123}  # d = dict( {‘name‘:‘jason‘,‘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‘:‘jason‘,‘name‘:‘tank‘,‘name‘:‘nick‘,‘password‘:123}

print(len(d2))

print(d2)

View Code

强调:字典的key是不能重复的,要唯一标识一条数据

如果重复了,只会按照最后一组重复的键值对存储

优先掌握的操作：

1、按key存取值：可存可取

d3 = {‘name‘:‘jason‘,‘password‘:‘123‘}

print(id(d3))

print(d3[‘name‘])

d3[‘name‘] = ‘egon‘

d3[‘name‘] = ‘kevin‘

d3[‘name‘] = ‘xxx‘

d3[‘name‘] = ‘ooo‘

 

d3[‘age‘] = 18  # 赋值语句当key不存在的情况下，会自动新增一个键值对(******)

print(d3,id(d3))

 

View Code

2、长度len

统计的键值对的个数

3、成员运算in和not in   对于字典来说只能判断key值

d3 = {‘name‘:‘jason‘,‘password‘:‘123‘}

print(‘123‘ in d3)

print(‘name‘ in d3)

4、删除

d3 = {‘name‘:‘jason‘,‘password‘:‘123‘}

del d3[‘name‘]

print(d3)

res = d3.pop(‘name‘)  # 弹出仅仅是value

res = d3.pop(‘age‘)  # 当键不存在的时候直接报错

print(res)

print(d3)

d3.clear()

print(d3)

  

View Code

定义字典的三种方式

掌握

d1 = {‘name‘:‘jason‘,‘password‘:123}

掌握

d2 = dict(name=‘jason‘,password=123,age=18)  # (******)

print(d2,type(d2))

5、键keys()，值values()，键值对items()

d1 = {‘name‘:‘jason‘,‘password‘:123}

 print(d1.keys())  # dict_keys([‘name‘, ‘password‘])  老母猪

for k in d1.keys():

     print(k)

print(d1.values())  # dict_values([‘jason‘, 123])  老母猪  现在就把它当成一个列表来看即可

print(d1.items())  # dict_items([(‘name‘, ‘jason‘), (‘password‘, 123)])

就把它看成是列表套元组，元组的第一个元素是字典的key 第二个元素是字典的value

get()根据key获取value（*******************************）

d1 = {‘name‘:‘jason‘,‘pwd‘: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.fromkeys()  快速的创建一个字典

l1 = [‘name‘,‘password‘,‘age‘,‘hobby‘]

print(dict.fromkeys(l1,123))

dict.popitem()

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

dict.setdefault()

d1 = {‘name‘:‘jason‘,‘pwd‘:123}

res1 = d1.setdefault(‘name‘,‘xxoo‘)  # 当键存在的情况下 不修改值 并且将原先key对应值返回给你

print(d1,res1)

res2 = d1.setdefault(‘age‘,18)  # 当键不存在的情况下 新增一个键值对 并且将新增的键值对的值返回给你

print(d1,res2)

dict.update()

d1 = {‘name‘:‘jason‘,‘pwd‘:123}

d2 = {"age":18}

d1.update(d2)

d1[‘age‘] = 18

d1.update(age=666)

print(d1)

6、循环

d1 = {‘name‘:‘jason‘,‘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‘>  如果你仅仅只写了一个大括号 那么python默认将它当做字典类型

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),[1,2]}  # 报错

s = {1,2,3,4,5,6,‘a‘,(1,2),{"name":‘jason‘}}  # 报错

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(pythons & linux)  # 交集

 

只报名python的学生姓名

print(pythons - linux)

 

只报名linux的学生姓名

print(linux - pythons)

 

没有同时报名两门课程的学生姓名

print(pythons ^ linux)  # 对称差集

 

取出所有报了名的学生姓名

print(pythons | linux)

View Code

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)

 

View Code

内置方法

原文：https://www.cnblogs.com/pangqian/p/11134941.html