标签：内置 jason name 补充 dic 111 l1 print 终章

内容概要

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

内容详细

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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。