Python基础05

本篇博客

1 列表

2 元组

3 字典

1 列表 [ ]

列表支持对元素的修改、删除等操作。列表也是一个序列式容器, 同样支持索引和切片语法。

# 创建一个空列表
my_li=[]

# 创建一个数字列表
my_li=[10,20,30]

# 创建一个字符串列表
my_li=['ad','ad','ff']

# 列表中再放列表
my_li=[[1,2,3],1]

# 列表中也可以存放不同类型的元素
my_li = [1,2,'a',[1,2,3],11.90]

# 建议列表中存放相同类型的数据
print(my_li)

my_li = [10,20,30,40]

# 列表是序列容器，支持索引和切片
print(my_li[0])
print(my_li[0:])

注意: 列表中支持存储不同类型的数据, 如果有没有特殊需求, 建议存储相同类型数据. 这样可以对数据应用统一的操作

字符串和列表作比较：

字符串中的元素不能修改，而且元素类型单一。

列表中的元素可以修改，并且可以存放多种类型的元素。

列表中的缺点：

在指定位置插入和删除元素，会造成数据元素的移动，效率较低。
根据关键字去查找数据的话，效率比较低。

列表中的优点：

根据索引查找元素效率较高
尾部插入和删除元素效率较高

1.1 列表操作

1.1.1 列表遍历

while 循环

my_li = [10,20,30,40]


# 列表的遍历,用的比较多
index = 0
while index < len(my_li):
    print(my_li[index])
    index += 1

for 循环

# for 循环中的遍历
my_li = [10,20,30,40]

for i in my_li:
    print(i)

注意： break continue用在循环中，可以用在for 循环中

1.1.2 列表查找 index

index 方法可以根据值查找, 查找到返回该值元素所在的位置（索引）, 查找失败会报错, 程序终止.

小案例：

1. 列表不存在类似字符串 replace 的方法. 2. 查询 10 这个元素在列表中的索引位置. 3. 根据索引位置修改元素为 200

my_li =[10,20,30,40]

# index 用于根据值查询，成功，返回索引。如果查询失败，则会报错。
old_num  = 10
new_num = 200
print(my_li)
if old_num in my_li:
    pos = my_li.index (old_num)
    my_li[pos] = new_num
    print(my_li)
else:
    print('没有这个数字')

in not in 运算符

1. in 可以判断元素是否存在, 存在返回 True, 不存在返回 False.

2. not in 可以判断元素是否不存在, 不存在返回 True, 存在返回 False.

1.1.3 列表修改

my_li =[10,20,30,40]
my_li[0]=100
print(my_li)

my_li[4]='a'
print(my_li)

注意：不存在的索引会报错。

1.1.4 列表的插入

插入分为：1 尾插（append） 2 指定位置插入(insert) 2 插入一个列表(多个元素) extend

append 方法, 用于向列表尾部添加元素,

my_li = []
my_li.append(10)
my_li.append(20)
my_li.append(30)
print(my_li)

insert 方法用于向列表指定的索引位置插入元素

my_li = [1,2,3]
my_li.insert(0,100)
print(my_li)

my_li.insert(2,200)
print(my_li)

extend 方法用于将另外一个列表中的所有元素追加到当前列表的尾部.

my_li = [1,2,3]
my_li2 = ['aaa','bb','cc']
my_li.extend(my_li2)
print(my_li)

1.15 列表的删除

删除分为：1 remove 根据值删 2 pop (有参，根据索引删；无参，删除最后一个) 3 clear 删除列表中所有元素

1. 根据值删除, 使用 remove 方法. 该方法只能删除第一次出现的值.

my_li = [100,200,300,200]

my_li.remove(200)
print(my_li)

2. 根据索引删除, 使用 pop 方法, 该方法不传递索引时默认删除最后一个元素, 传递索引则根据索引删除元素.

my_li = [100,200,300,200]

my_li.pop()
print(my_li)

my_li.pop(1)
print(my_li)

3 clear 删除列表中所有元素

my_li = [100,200,300,200]

my_li.clear()
print('列表的长度',len(my_li))

1.16 列表的排序 sort()

1. 不写，默认列表中的元素升序(从小到大) 降序排列(从大到小). reverse=True
2. 将列表中的元反转. reverse()

my_li = [100,200,300,3,2,5,10,2]
print(my_li)

# 对列表中的元素进行排序
# sort 默认是从小到大 升序
my_li.sort()
print(my_li)  # 从小到大

my_li.sort(reverse=True)
print(my_li) # 从大到小

# 逆序
my_li.reverse()
print(my_li)

1.17 列表的练习

一个学校, 有3个办公室, 现在有 8 位老师等待工位的分配, 请编写程序, 完成随机的分配

思考：

1. 待分配的 8 位老师需要存储, 我们可以用列表来暂时存储 8 位老师.
2. 一个学校中包含了多个办公室, 学校可用列表来表示, 学校中又包含了多个办公室, 每个办公室里可能有多个老
师, 办公室仍然可用列表来表示.
3. 从待分配老师列表中取出数据, 随机产生办公室编号, 将该老师分配到该办公室.
4. 打印各个办公室中的老师列表

# 一个学校, 有3个办公室, 现在有 8 位老师等待工位的分配, 请编写程序, 完成随机的分配
import random
school_room = [[],[],[]]


def create_teacher():
    teacher_li = []
    i = 1
    while i <= 8:
        teacher_name = '老师'+str(i)
        teacher_li.append(teacher_name)
        i += 1
    return teacher_li

teacher_li1 = create_teacher()
# print(teacher_li1,id(teacher_li1))

# 函数调用多次，每次都返回新的对象。
# teacher_li2 = create_teacher()
# print(teacher_li2,id(teacher_li2))

# 分配老师
for person in teacher_li1:
    num = random.randint(0,2)
    school_room[num].append(person)

# print(school_room)

for i in school_room:
    for j in i:
        print(j, end=' ')
    print(' ')

1.2 小结

1. 列表一般使用一对中括号 [ ] 来定义.
2. 列表容器的特点: 可以存储任意类型的数据, 并且元素可以修改.
3. 列表中存储的元素类型可不相同, 但建议存储同样的类型.
4. 列表是序列式容器, 支持下标索引和切片操作.
5. 列表遍历可以使用 while 循环, 也可以使用 for 循环.
6. 列表可通过 in 或 not in 运算符来判断是否存在某个元素.
7. 列表的 append 方法用于向列表尾部添加元素.
8. 列表的 insert 方法用于向列表指定索引位置添加元素.
9. 列表的 extend 方法用于将一个列表中所有元素添加到当前列表的尾部.
10. 列表的 pop 方法默认删除尾部元素, 如果设置索引参数, 可删除该索引位置的元素.
11. 列表的 reverse 方法可以将列表中元素逆序.
12. 列表的 sort 方法可以将列表中的元素升序或者降序排列

2 元组

元组使用小括号来定义, .由于元组不支持修改, 所以元组只支持遍历、查找操作.

注意：不支持修改指的是不能删除元素，不能指定索引赋值。但是可以+ ,+=操作。

2.1 元组语法和方法

元组同样属于序列式容器, 支持索引和切片语法.
1. 查询元素: count 、 index
2. 遍历操作: while、for

my_tuple = (10,20,30)
print(my_tuple[0])

# 一个元素，加逗号
my_tuple = (10,)
print(my_tuple)

# 元祖嵌套元祖
my_tuple = ((1,2),(10,20))
print(my_tuple)
my_tuple = ((1,),)

# 元祖中的数字一旦创建就不能修改
my_tuple = (1,2,3)
# my_tuple[0]=4

for i in my_tuple:
    print(i)

# 查询
pos = my_tuple.index(3)
print(pos)

# 元祖支持切片操作
print(my_tuple[1:])

my_tuple = (11,1,1)
# res =my_tuple+(1,2)
# print(res)
my_tuple+=(3,3,3)
print(my_tuple)

2.2 小结

1. 元组使用一对小括号来定义, 在定义之后不允许对元素进行修改.
2. 元组中只有一个元素时, 需在最尾部添加一个逗号.
3. 元组是序列式容器, 支持索引、切片操作.
4. 元组比列表更节省空间.

3 字典

字典中存储的每一个元素都是键值对, 并且在字典中根据键(关键字)去查找某个元素的效率非常高.

为了实现高的查询效率, 字典被实现成了一种非序列式容器, .查找效率较高，但是比较占内存，字典以空间换时间。

3.1 字典语法格式

字典中的每一个元素都是一个 "键值对", 键值之间用冒号(:)分割, 每个字典元素 (键值对)之间用逗号(,)分割, 整个字典包括在花括号 {} 中

my_dict = {key1: value1, key2: value2, key3: value3}

注意：

1. 键一般是唯一的, 如果重复最后的一个键值对会替换前面的, 键的类型一般情况下使用字符串、数字类型.

2. 值不需要唯一, 可以为任何的数据类型

3. 也就导致字典无法根据索引获得元素, 同样也不支持切片操作

3.2 字典操作

3.2.1 访问元素

1. 直接通过键来获得, 但当键不存在时, 会抛出错误.

my_dict = {'name':'zyc','age':18,'gender':'女'}
print(my_dict['name'])
# print(my_dict['city'])

2. 通过 get 方法来根据键获得值, 如果键不存在则会返回 None, 该返回默认值也可自定义.

my_dict = {'name':'zyc','age':18,'gender':'女'}
print(my_dict.get('age','我是默认值'))
print(my_dict.get('age1','我是默认值'))

3.2.2 添加和修改元素

如果key 不存在，就添加元素，有，就修改

my_dict = {'name':'zyc','age':18,'gender':'女'}
print(my_dict)
my_dict['city'] = 'shanghai'
print(my_dict)
my_dict['gender'] = '男'
print(my_dict)

3.2.3 删除元素

Python 中字典中元素的删除, 需要根据键来进行, 我们可以使用del方法，和 pop 方法，来根据 key 来删除字典中的元素，也可以clear 清空字典

person = {'name': 'Obama', 'age': 18, 'sex': '男'}
print(person)

# 删除某个元素
person.pop('name')
print(person)

# del 删除字典的键
del person['age']
print(person)

# 清空字典
person.clear()
print(person)

del 也可以删变量和列表中的元素。

# del 删变量，删列表中的元素
a=10
print(a)

# del a
# print(a)

li=[1,2,3]
print(li)

del li[0]
print(li)

3.2.4 遍历元素

1. 获得字典键的列表, 通过字典的 keys 方法.
2. 获得字典值的列表, 通过字典的 values 方法.
3. 获得字典的键值对列表, 通过字典的 items 方法

person = {'name': 'Obama', 'age': 18, 'sex': '男'}
# 获得字典的值列表
print(person.values())
# 获得字典的键列表
print(person.keys())
# 获得字典的键值对列表
print(list(person.items()))
for key, value in person.items():
    print(key, value)

使用while循环遍历

person = {'name': 'Obama', 'age': 18, 'sex': '男'}
my_li = list(person.items())
i = 0
while i < len(my_li):
    print(my_li[i][0],my_li[i][1])
    i += 1

3.3 小结

1. 字典通过一对花括号 "{}" 来定义, 每一个元素都是一个键值对.
2. 字典不支持索引、切片操作.
3. 字典根据键查询元素的效率非常高.
4. 字典的键一般情况下是数字、字符串等, 键必须唯一不重复.
5. 字典的值可以重复, 任意类型.
6. for 循环无法直接遍历字典, 需要先将字典转换为类似列表那样能够被迭代的类型.
7. 字典的 get 方法可以根据键获得值, 如果键不存在返回默认值.
8. 字典的 pop 方法可以根据键来删除字典中某个元素.
9. 字典的 clear 方法可用来清空字典.
10. 字典的 keys 方法可以返回一个由字典的键组成的列表.
11. 字典的 values 方法可以返回一个由字典的值组成的列表.
12. 字典的 items 方法将每一个键值对存放到元组中, 然后将元组列表返回.