内置方法

1.列表的内置方法

1.sort（reverse=True）参数指定 降序

l1 = [44, 22, 11, 33, 99, 77, 88, 66]
l1.sort(reverse=True)  # [99, 88, 77, 66, 44, 33, 22, 11]
print(l1)

2.reverse() 顺序颠倒

l1 = [44, 22, 11, 33, 99, 77, 88, 66]
l1.reverse()
print(l1)

3.比较

ll1 = [999, 111]
ll2 = [111, 222, 333, 444, 555, 666, 777, 888]
print(ll1 > ll2)  # True
# 列表比较运算采用相同索引元素比较 只要有一个比出了结果就直接
s1 = 'hello world'
s2 = 'abc'
print(s1 > s2)  # True
# 字符串比较大小也是按照索引位置内部转成ASCII对应的数字比较

4.切片

l1 = [44, 22, 11, 33, 99, 77, 88, 66]
print(l1[1:5])  # [22, 11, 33, 99]
# 冒号左右两边不写数字默认全都要
print(l1[::-1])  # [66, 88, 77, 99, 33, 11, 22, 44]
print(l1[:5])  # [44, 22, 11, 33, 99]左边不写默认从头开始
print(l1[1:])  # [22, 11, 33, 99, 77, 88, 66]右边不写默认到尾

 

 

2.字典的内置方法

1.定义字典

# 1. 定义字典
d = {'username': 'ly', 'age': 12}

2. 第二种方式dict

d1 = dict(name='ly', age=18, gender='male')
print(d1)

3.按k取值  k不存在会直接报错

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(dic['name']) # ly
print(dic['pwd'])  # 报错

4.按k修改值 新增键值对

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
dic['name'] = 'ly'     # k值 存在，直接进行修改操作
dic['pwd'] = '123456'  # k值不存在，会往字典中添加一个k:v
print(dic)

5.求长度

l = [1, 2, 3, 4, 5, 6]
print(len(l))

6.成员运算

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print('jason' in dic)  # False
print('name' in dic)  # True

 

 

7.删除元素

1.方式一

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
# 方式1
del dic['name']  # {'age': 18, 'hobbies': ['play game', 'basketball']}
print(dic)

2.方式二

指定k弹出键值对 给出v

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}

print(dic.pop('age'))  # 18
print(dic)

3.方式三

出键值对 组织成元组的形式 第一个元素是k第二个元素是v

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}

print(dic.popitem())  # ('hobbies', ['play game', 'basketball'])
print(dic)  # {'name': 'jason', 'age': 18}

8.获取v值

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(dic['name'])  # jason  键不存在直接报错  按k取值不太推荐使用该方式
print(dic['bbb'])  #  键不存在直接报错  按k取值不太推荐使用该方式

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(dic.get('name'))  #xxx
print(dic.get('bbb'))  # None  键不存在 不会报错返回None
print(dic.get('name', '哈哈哈'))  # 第二个参数 可以在k不存在的时候自定义返回信息
print(dic.get('bbb', '哈哈哈'))  # 第二个参数 可以在k不存在的时候自定义返回信息

9.keys()values()  items()  在python2中是列表

在python3中是迭代器

 

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(dic.keys())  # dict_keys(['name', 'age', 'hobbies'])  获取字典所有的键 看成列表即可
print(dic.values())  # dict_values(['xxx', 18, ['play game', 'basketball']])  获取字典所有的值 看成列表即可
print(dic.items())  # dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])
# 获取字典里面所有的键值对 组织成列表套元组的形式 元组内有两个元素 第一个是k第二个是v

10.更新字典  键存在则修改 不存在则创建

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
dic.update({'name': 'jasonNB', 'pwd': 123})
# {'name': 'xxxx', 'age': 18, 'hobbies': ['play game', 'basketball'], 'pwd': 123
print(dic)

11.初始化字典

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(dict.fromkeys(['k1', 'k2', 'k3'], []))

12.当键存在的情况下 不修改而是获取该键对应的值

dic = {
    'name': '',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(dic.setdefault('name', 'xxxx'))
print(dic)

当键不存在的情况下 新增一组键值对 并且该方法的结果是新增的值

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(dic.setdefault('pwd', '123'))
print(dic)

 

 

3.元组内置方法

1.元组是什么？

小括号括起来 内部存放多个元素 元素与元素逗号隔开
元素可以是任意数据 但是元组内元素不支持‘修改’(索引指向的元素的内存地址不能改变)
也可以简单的认为它是一个不可变的列表

2.类型转换  能够支持for循环的数据都可以转换成元组

1 # print(tuple(111))
2 # print(tuple(11.11))
3 # print(tuple('hello'))  # ('h', 'e', 'l', 'l', 'o')
4 # print(tuple([11,22,33]))  # (11, 22, 33)
5 # print(tuple({'name':'jason','pwd':123}))  # ('name', 'pwd')

3.元组第一道笔试题

 1 # t1 = (111)  # 整型
 2 # t2 = (11.11)  # 浮点型
 3 # t3 = ('hello')  # 字符串
 4 """
 5 元组哪怕内部只有一个元素 也需要加上逗号
 6 """
 7 # print(type((111,)))
 8 '''
 9 容器类型:内部可以存放多个值的数据类型都可以称之为容器类型
10     建议:所有的容器类型在存储数据的时候 如果内部只有一个元素 
11         那么也推荐你加上逗号
12 '''

4.索引取值

1 t = (111, 222, 333, 444, 555)
2 print(t[2])  # 333
3 print(t[-1])  # 555

5.切片操作

1 t = (111, 222, 333, 444, 555)
2 print(t[1:5])
3 print(t[1:])
4 print(t[:])

6.步长

1 t = (111, 222, 333, 444, 555)
2 print(t[1:5:2])  # (222, 444)

7.统计元组内元素的个数

1 t = (111, 222, 333, 444, 555)
2 print(len(t))  # 5

8.for循环

t = (111, 222, 333, 444, 555)
for i in t:
    print(i)

9.count计数

1 t = (111, 222, 333, 444, 555)
2 print(t.count(111))  # 1

笔试题

1 t1 = (111, 222, [11, 22, 33])
2 t1[2].append(44)
3 print(t1)

 

 

4.集合去重操作

1.定义空集合需要使用关键字set

s1 = set()

2.类型转换  能够支持for循环的数据类型都可以转成集合(元素要是不可变类型)

集合内元素是无序的

3.去重

print(set(ll))  # {33, 66, 11, 44, 77, 22, 55}

4.先将列表转换成集合再将去重之后的集合转换成列表

1 s1 = {1, 2, 2, 2, 3, 4, 3, 4, 3, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3}
2 print(s1)  # {1, 2, 3, 4}
3 name_list = ['kevin', 'an', 'an', 'an', 'kevin', 'kevin']
4 s1 = set(name_list)
5 l1 = list(s1)
6 print(l1)

 

 

5.集合关系运算

1.关系运算

两个群体之间做差异比较    共同好友 共同关注

2.求两个用户的共同好友

friends1 = {"zero", "kevin", "an", "eg"}  # 用户1的好友们
friends2 = {"Jy", "ricky", "an", "eg"}  # 用户2的好友们
print(friends1 & friends2)  # {'an', 'eg'}

3.求两个用户所有的好友

1 friends1 = {"zero", "kevin", "an", "eg"}  # 用户1的好友们
2 friends2 = {"Jy", "ricky", "an", "eg"}  # 用户2的好友们
3 print(friends1 | friends2)  # {'kevin', 'ricky', 'an', 'zero', 'Jy', 'eg'}

4.求用户1独有的好友

1 friends1 = {"zero", "kevin", "an", "eg"}  # 用户1的好友们
2 friends2 = {"Jy", "ricky", "an", "eg"}  # 用户2的好友们
3 print(friends1 - friends2)  # {'zero', 'kevin'}

5..求用户2独有的好友

1 friends1 = {"zero", "kevin", "an", "eg"}  # 用户1的好友们
2 friends2 = {"Jy", "ricky", "an", "eg"}  # 用户2的好友们
3 print(friends2 - friends1)  # {'ricky', 'Jy'}

6.求用户1和用户2各自的好友

1 friends1 = {"zero", "kevin", "an", "eg"}  # 用户1的好友们
2 friends2 = {"Jy", "ricky", "an", "eg"}  # 用户2的好友们
3 print(friends1 ^ friends2)  # {'Jy', 'zero', 'kevin', 'ricky'}

7.父集与子集

# s1 = {11, 22, 33, 44}
# s2 = {11, 33}
# print(s1 > s2)  # 判断s1是否是s2的父集   True
# print(s2 < s1)  # 判断s2是否是s1的子集   True