内容概要

• 列表内置方法补充
• 字典内置方法
• 元组内置方法
• 元组相关笔试题
• 集合内置方法
• 字符编码(理论多结论少)

内容详细

1.队列和堆栈

• 队列:先进先出
  例：
  1.定义一个空列表
  l1 = []
  2.先进
  l1.append(111)
  l1.append(222)
  l1.append(333)
  3.先出
  print(l1.pop(0))
  print(l1.pop(0))
  print(l1.pop(0))
  

• 堆栈:先进后出
  例：
  1.定义一个空列表
  l2 = []
  2.添加元素
  l2.append(111)
  l2.append(222)
  l2.append(333)
  3.尾部弹出元素
  print(l2.pop())
  print(l2.pop())
  print(l2.pop())
  

2.列表其他方法

例：
l1 = [44, 22, 11, 33, 99, 77, 88, 66]
关键词：sort
l1.sort()
print(l1)
结果：
[11, 22, 33, 44, 66, 77, 88, 99]

l1.sort(reverse=True) # 参数指定 降序
print(l1)
结果：
[99, 88, 77, 66, 44, 33, 22, 11]

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

l1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(l1[1:5])
print(l1[::-1]) # 冒号左右两边不写数字默认全都要
print(l1[:5]) # 左边不写默认从头开始
print(l1[1:]) # 右边不写默认到尾部
结果：
[1, 2, 3, 4]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
[0, 1, 2, 3, 4]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

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.字典内置方法

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

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

2.按k修改值 新增键值对(使用频率最高)

dic['name'] = 'jasonNB'
print(dic)
结果：
{'name': 'jasonNB', 'age': 18, 'hobbies': ['play game', 'basketball']}

dic['hobbies'].append('read')
print(dic)
结果：
{'name': 'jason', 'age': 18, 'hobbies': ['play game', 'basketball', 'read']}

• 键不存在为新增键值对：
  dic['pwd'] = 123
  print(dic)
  结果：
  {'name': 'jason', 'age': 18, 'hobbies': ['play game', 'basketball'], 'pwd': 123}
  

3.统计字典内部键值对的个数

关键词：len
print(len(dic))
结果：
3

4.成员运算 默认只暴露k

print('jason' in dic)
print('name' in dic)
结果：
False
True

5.删除元素

方式一：
del dic['name']
print(dic)
结果：
{'age': 18, 'hobbies': ['play game', 'basketball']}

方式二：
指定k弹出键值对 给出v
print(dic.pop('age'))
print(dic)
结果：
18
{'name': 'jason', 'hobbies': ['play game', 'basketball']}

方式三：
弹出键值对 组织成元组的形式 第一个元素是k第二个元素是v(了解)
print(dic.popitem())
print(dic)
结果：
('hobbies', ['play game', 'basketball'])
{'name': 'jason', 'age': 18}

6.获取v值

print(dic['name'])
结果：
jason

但键不存在直接报错 按k取值不太推荐使用该方式

print(dic.get('name'))
结果：
jason

键不存在 不会报错返回None 推荐使用

print(dic.get('name', '哈哈哈')
结果：
jason

第二个参数 可以在k不存在的时候自定义返回信息

7.keys() values() items()

在python2中是列表 在python3中是迭代器
print(dic.keys())
结果：
dict_keys(['name', 'age', 'hobbies'])
获取字典所有的键 看成列表即可

print(dic.values())
结果：
dict_values(['jason', 18, ['play game', 'basketball']])
获取字典所有的值 看成列表即可

print(dic.items())
结果：
dict_items([('name', 'jason'), ('age', 18), ('hobbies', ['play game', 'basketball'])])
获取字典里面所有的键值对 组织成列表套元组的形式 元组内有两个元素 第一个是k第二个是v

5.字典需要了解方法

• 更新字典 键存在则修改 不存在则创建
  dic = {
  'name': 'jason',
  'age': 18,
  'hobbies': ['play game', 'basketball']
  }
  dic.update({'name': 'jasonNB', 'pwd': 123})
  print(dic)
  结果：
  {'name': 'jasonNB', 'age': 18, 'hobbies': ['play game', 'basketball'], 'pwd': 123}
  

• 初始化字典
  print(dict.fromkeys(['k1', 'k2', 'k3'], []))
  结果：
  

• 笔试题
  res = dict.fromkeys(['k1', 'k2', 'k3'], [])
  res['k1'].append(111)
  res['k2'].append(222)
  res['k3'].append(333)
  res['k1'] = [111,222,333]
  res['k1'].append(444)
  print(res)
  结果：
  {'k1': [111, 222, 333, 444], 'k2': [111, 222, 333], 'k3': [111, 222, 333]}
  

• 当键存在的情况下 不修改而是获取该键对应的值
  print(dic.setdefault('name', 'jasonNB'))
  print(dic)
  结果：
  jason
  {'name': 'jason', 'age': 18, 'hobbies': ['play game', 'basketball']}
  

• 当键不存在的情况下 新增一组键值对 并且该方法的结果是新增的值
  print(dic.setdefault('pwd', '123'))
  print(dic)
  结果：
  123
  {'name': 'jason', 'age': 18, 'hobbies': ['play game', 'basketball'], 'pwd': '123'}
  

6.元组内置方法

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

• 类型转换
  能够支持for循环的数据都可以转换成元组
  转换方式：
  print(tuple(111))
  print(typle(11.1))
  print(tuple('hello')) # ('h', 'e', 'l', 'l', 'o')
  print(tuple([11,22,33])) # (11, 22, 33)
  print(tuple({'name':'jason','pwd':123})) # ('name', 'pwd')

• 元组第一道笔试题
  t1 = (111)
  t2 = (11.1)
  t3 = ('hello')
  

书写格式：
元组哪怕内部只有一个元素 也需要加上逗号
print(type((111,)))

例：
t = (111, 222, 333, 444, 555)

1.索引取值

print(t[2])
print(t[-1])

2.切片操作

print(t[1:5])
print(t[1:])
print(t[:])

3.步长

print(t[1:5:2])

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

print(len(t))

5.for循环

for i in t:
print(i)

6.count计数

print(t.count(111))

• 笔试题
  t1 = (111, 222, [11, 22, 33])
  t1[2].append(44)
  print(t1)
  

7.集合去重操作

定义空集合需要使用关键字set
s1 = set()

例：
s1 = {1, 2, 2, 2, 3, 4, 3, 4, 3, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3}
print(s1)

name_list = ['kevin', 'jason', 'jason', 'jason', 'kevin', 'kevin']
先将列表转换成集合
s1 = set(name_list)
再将去重之后的集合转换成列表
l1 = list(s1)
print(l1)

练习题：
ll = [33, 22, 11, 22, 11, 44, 33, 22, 55, 66, 77, 77, 66, 55, 44]
s1 = set(ll)
ll1 = list(s1)
print(ll1)
基本要求:去重即可

拔高要求:去重并保留原来的顺序
1.先定义一个新列表
new_list = []
2.for循环ll列表
for i in ll:
3.判断当前元素是否在新列表中
if i not in new_list:
3.1 如果不在 则添加到新列表
new_list.append(i)
3.2 如果在 则不管
print(new_list)

8.集合关系运算

两个群体之间做差异比较
friends1 = {"zero", "kevin", "jason", "eg"} # 用户1的好友们
friends2 = {"Jy", "ricky", "jason", "eg"} # 用户2的好友们

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

print(friends1 & friends2)

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

print(friends1 | friends2)

3.求用户1独有的好友

print(friends1 - friends2)

4.求用户2独有的好友

print(friends2 - friends1)

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

print(friends1 ^ friends2)

6.父集与子集

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

标签：内置,jason,name,补充,dic,111,l1,print,终章
来源： https://www.cnblogs.com/jgx0/p/15529074.html