3.查找元素("查"in, not in, index, count)
所谓的查找，就是看看指定的元素是否存在
in, not in
index, count
下标
len()：访问列表长度，即列表中数据的个数。
4.删除元素("删"del, pop, remove)
demo:(del)
demo:(pop)
demo:(remove)
demo:(clear)[清空列表]
name_list = [‘TOM’, ‘Lily’, ‘ROSE’]
1. del
del name_list
del(name_list)
del 可以删除指定下标的数据
del name_list[0]
print(name_list)
2. pop() – 删除指定下标的数据，如果不指定下标，默认删除最后一个数据，
无论是按照下标还是删除最后一个，pop函数都会返回这个被删除的数据
del_name = name_list.pop()
del_name = name_list.pop(1)
print(del_name)
print(name_list)
3. remove(数据)
name_list.remove(‘ROSE’)
print(name_list)
4. clear() – 清空
name_list.clear()
print(name_list)
5.排序(sort, reverse)
name_list = [‘TOM’, ‘Lily’, ‘ROSE’]
1. 修改指定下标的数据
name_list[0] = ‘aaa’
print(name_list)
2. 逆序 reverse()
list1 = [1, 3, 2, 5, 4, 6]
list1.reverse()
print(list1)
3. sort() 排序：升序(默认) 和 降序
list1.sort()
list1.sort(reverse=False)
list1.sort(reverse=True)
print(list1)
6.复制(copy)
name_list = [‘TOM’, ‘Lily’, ‘ROSE’]
list1 = name_list.copy()
print(list1)
print(name_list)
1.使用for循环
name_list = [‘TOM’, ‘Lily’, ‘ROSE’]
for i in name_list:
遍历序列中的数据
print(i)
2.使用while循环
name_list = [‘TOM’, ‘Lily’, ‘ROSE’]
‘’’
-
准备表示下标数据
-
循环while
条件 i < 3 len()
遍历：依次按顺序访问到序列的每一个数据
i += 1
‘’’
i = 0
while i < len(name_list):
print(name_list[i])
i += 1
1.列表嵌套
name_list = [[‘TOM’, ‘Lily’, ‘Rose’], [‘张三’, ‘李四’, ‘王五’], [‘xiaohong’, ‘xiaoming’, ‘xiaolv’]]
print(name_list)
列表嵌套的时候的数据查询
print(name_list[0])
print(name_list[0][1])
2.应用
一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配
需求：8位老师，3个办公室， 将8位老师随机分配到3个办公室
“”"
步骤：
- 准备数据
1.1 8位老师 – 列表
1.2 3个办公室 - 列表嵌套
- 分配老师到办公室
*** 随机分配
就是把老师的名字写入到办公室列表 – 办公室列表追加老师名字数据
- 验证是否分配成功
打印办公室详细信息：每个办公室的人数和对应的老师名字
“”"
import random
1. 准备数据
teachers = [‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’, ‘G’, ‘H’]
offices = [[], [], []]
2. 分配老师到办公室 – 取到每个老师放到办公室列表 – 遍历老师列表数据
for name in teachers:
列表追加数据 – append（选中） extend insert
xx[0] – 不能指定是具体某个下标 – 随机
num = random.randint(0, 2)
offices[num].append(name)
print(num)
print(offices)
为了更贴合生活，把各个办公室子列表加一个办公室编号 1， 2， 3
i = 1
3. 验证是否分配成功
for office in offices:
打印办公室人数 – 子列表数据的个数 len()
print(f’办公室{i}的人数是{len(office)}，老师分别是：')
打印老师的名字
print() – 每个子列表里面的名字个数不一定 – 遍历 – 子列表
for name in office:
print(name)
i += 1
t1 = (10, 20, 30)
print(t1)
print(type(t1))
1. 多个数据元组
t1 = (10, 20, 30)
print(type(t1))
2. 单个数据的元组
t2 = (10,)
print(type(t2))
3. 如果单个数据的元组不加逗号
t3 = (10)
print(type(t3)) # int
t4 = (‘aaa’)
print(type(t4)) # str
t5 = (‘aaa’,)
print(type(t5))
t1 = (‘aa’, ‘bb’, ‘cc’, ‘bb’)
1. 下标
print(t1[0])
2. index()
print(t1.index(‘bb’))
print(t1.index(‘bbb’))
3. count()
print(t1.count(‘aa’))
print(t1.count(‘aaa’))
4. len()
print(len(t1))
t1 = (‘aa’, ‘bb’, ‘cc’, ‘bb’)
t1[0] = ‘aaa’
t2 = (‘aa’, ‘bb’, [‘cc’, ‘dd’])
print(t2[2])
print(t2[2][0])
t2[2][0] = ‘TOM’
print(t2)
1.生活中的字典
2.软件开发中的字典
创建字典
{} 键值对 各个键值对用逗号隔开
1. 有数据的字典： name的值TOM， age的值是20， gender的值是男
dict1 = {‘name’: ‘TOM’, ‘age’: 20, ‘gender’: ‘男’}
print(dict1)
print(type(dict1))
2. 创建空字典
dict2 = {}
print(type(dict2))
dict3 = dict()
print(type(dict3))
3.根据键访问值
1.查看元素
dict1 = {‘name’: ‘TOM’, ‘age’: 20, ‘gender’: ‘男’}
1. [key]
print(dict1[‘name’]) # 返回对应的值(key存在)
print(dict1[‘names’])
2. 函数
2.1 get()
print(dict1.get(‘name’))
print(dict1.get(‘names’)) # 如果key不存在，返回None
print(dict1.get(‘names’, ‘Lily’))
2.2 keys() 查找字典中所有的key，返回可迭代对象
print(dict1.keys())
2.3 values() 查找字典中的所有的value，返回可迭代对象
print(dict1.values())
2.4 items() 查找字典中所有的键值对，返回可迭代对象，里面的数据是元组，元组数据1是字典的key，元组数据2是字典key对应的值
print(dict1.items())
2.修改元素
dict1 = {‘name’: ‘TOM’, ‘age’: 20, ‘gender’: ‘男’}
dict1[‘name’] = ‘Lily’
print(dict1)
dict1[‘id’] = 110
print(dict1)
3.添加元素
dict1 = {‘name’: ‘TOM’, ‘age’: 20, ‘gender’: ‘男’}
字典序列[key] = 值
id的值是110
dict1[‘id’] = 110
print(dict1)
dict1[‘name’] = ‘ROSE’
print(dict1)
4.删除元素
dict1 = {‘name’: ‘TOM’, ‘age’: 20, ‘gender’: ‘男’}
del 删除字典或指定的键值对
del(dict1)
print(dict1)
del dict1[‘name’]
del dict1[‘names’] # 报错
print(dict1)
clear()
dict1.clear()
print(dict1)
5.len()
6.keys
dict1 = {‘name’: ‘TOM’, ‘age’: 20, ‘gender’: ‘男’}
for key in dict1.keys():
print(key)
7.values
dict1 = {‘name’: ‘TOM’, ‘age’: 20, ‘gender’: ‘男’}
for value in dict1.values():
print(value)
8.items
dict1 = {‘name’: ‘TOM’, ‘age’: 20, ‘gender’: ‘男’}
for item in dict1.items():
print(item)
dict1 = {‘name’: ‘TOM’, ‘age’: 20, ‘gender’: ‘男’}
xx.items(): 返回可迭代对象，内部是元组，元组有2个数据
元组数据1是字典的key，元组数据2是字典的value
for key, value in dict1.items():
print(key)
print(value)
目标： key=value
print(f’{key}={value}')
9.has_key （Python3 已取消）
1.字符串遍历
2.列表遍历
3.元组遍历
4.字典遍历
遍历字典的key（键）
遍历字典的value（值）
遍历字典的项（元素）
遍历字典的key-value（键值对）
5. 想一想，如何实现带下标索引的遍历
6.字典的扩展
有序字典:OrderDcit
1.创建集合
1. 创建有数据的集合
s1 = {10, 20, 30, 40, 50}
print(s1)
s2 = {10, 30, 20, 40, 30, 20}
print(s2)
s3 = set(‘abcdefg’)
print(s3)
2. 创建空集合: set()
s4 = set()
print(s4)
print(type(s4))
s5 = {}
print(type(s5))
2.集合常见操作方法
增加数据
s1 = {10, 20}
1. 集合是可变类型
add()
s1.add(100)
print(s1)
集合有去重功能，如果追加的数据是集合已有数据，则什么事情都不做
s1.add(100)
print(s1)
s1.add([10, 20, 30]) # 报错
print(s1)
update()： 增加的数据是序列
s1.update([10, 20, 30, 40, 50])
print(s1)
s1.update(100) # 报错
print(s1)
删除数据
s1 = {10, 20, 30, 40, 50}
remove(): 删除指定数据，如果数据不存在报错
s1.remove(10)
print(s1)
s1.remove(10) # 报错
print(s1)
discard()：删除指定数据，如果数据不存在不报错
s1.discard(10)
print(s1)
s1.discard(10)
print(s1)
pop(): 随机删除某个数据，并返回这个数据
del_num = s1.pop()
print(del_num)
print(s1)
查找数据
s1 = {10, 20, 30, 40, 50}
in 或not in 判断数据10是否存在
print(10 in s1)
print(10 not in s1)
1.运算符
+
str1 = ‘aa’
str2 = ‘bb’
list1 = [1, 2]
list2 = [10, 20]
t1 = (1, 2)
t2 = (10, 20)
dict1 = {‘name’: ‘Python’}
dict2 = {‘age’: 30}
+: 合并
print(str1 + str2)
print(list1 + list2)
print(t1 + t2)
print(dict1 + dict2) # 报错：字典不支持合并运算
*
str1 = ‘a’
list1 = [‘hello’]
t1 = (‘world’,)
*:复制
print(str1 * 5)
打印10个-：
print(‘-’ * 10)
print(list1 * 5)
print(t1 * 5)
in或not in
str1 = ‘abcd’
list1 = [10, 20, 30, 40]
t1 = (100, 200, 300, 400)
dict1 = {‘name’: ‘Python’, ‘age’: 30}
in 和 not in
1. 字符a是否存在
print(‘a’ in str1)
print(‘a’ not in str1)
2. 数据10是否存在
print(10 in list1)
print(10 not in list1)
3. 100是否存在
print(100 not in t1)
print(100 in t1)
4. name是否存在
print(‘name’ in dict1)
print(‘name’ not in dict1)
print(‘name’ in dict1.keys())
print(‘name’ in dict1.values())
2.公共方法
len()
str1 = ‘abcdefg’
list1 = [10, 20, 30, 40, 50]
t1 = (10, 20, 30, 40, 50)
s1 = {10, 20, 30, 40, 50}
dict1 = {‘name’: ‘TOM’, ‘age’: 18}
del()
str1 = ‘abcdefg’
list1 = [10, 20, 30, 40, 50]
t1 = (10, 20, 30, 40, 50)
s1 = {10, 20, 30, 40, 50}
dict1 = {‘name’: ‘TOM’, ‘age’: 18}
del 目标 或del(目标)
del str1
print(str1)
del(list1)
print(list1)
del(list1[0])
print(list1)
del s1
print(s1)
del dict1
print(dict1)
del dict1[‘name’]
print(dict1)
max()
min()
str1 = ‘abcdefg’
list1 = [10, 20, 30, 40, 50]
max() : 最大值
print(max(str1))
print(max(list1))
min() ： 最小值
print(min(str1))
print(min(list1))
range()
range(start, end, step)
print(range(1, 10, 1))
for i in range(1, 10, 1):
print(i)
for i in range(1, 10):
print(i)
for i in range(1, 10, 2):
print(i)
for i in range(10):
print(i)
1. 如果不写开始，默认从0开始
2. 如果不写步长，默认为1
enumerate()
list1 = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’]
enumerate 返回结果是元组，元组第一个数据是原迭代对象的数据对应的下标，元组第二个数据是原迭代对象的数据
for i in enumerate(list1):
print(i)
for i in enumerate(list1, start=1):
print(i)
3.容器类型转换
tuple()
list()
set()
list1 = [10, 20, 30, 20, 40, 50]
s1 = {100, 300, 200, 500}
t1 = (‘a’, ‘b’, ‘c’, ‘d’, ‘e’)
tuple(): 转换成元组
print(tuple(list1))
print(tuple(s1))
list()：转换成列表
print(list(s1))
print(list(t1))
set()：转换成集合
print(set(list1))
print(set(t1))
最后
不知道你们用的什么环境，我一般都是用的Python3.6环境和pycharm解释器，没有软件，或者没有资料，没人解答问题，都可以免费领取（包括今天的代码），过几天我还会做个视频教程出来，有需要也可以领取~
给大家准备的学习资料包括但不限于：
Python 环境、pycharm编辑器/永久激活/翻译插件
python 零基础视频教程
Python 界面开发实战教程
Python 爬虫实战教程
Python 数据分析实战教程
python 游戏开发实战教程
Python 电子书100本
Python 学习路线规划
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
886
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
