python基础day5_在python中,pop()、extend()、append()、sort()、+操作符,哪些操作会-优快云博客

本文链接：https://blog.youkuaiyun.com/joekl/article/details/146276868

一.列表

1.怎么理解python中列表是一个可变的容器这句话

1. 容器（Container）

列表是一种数据结构，用于存储多个元素。
它可以包含任意类型的对象（如整数、字符串、其他列表等），并且这些元素是有序的（即可以通过索引访问）。

a = [1,'dad','=']
print(a)



[1, 'dad', '=']

2. 可变（Mutable）

可变意味着列表的内容可以在不改变其内存地址的情况下被修改。

具体来说，列表支持以下操作：

my_list = [1, 2, 3]
my_list.append(4)       # 添加元素
my_list[0] = 10         # 修改元素
del my_list[1]          # 删除元素
print(my_list)         # 输出: [10, 3, 4]

添加元素：例如使用 append()、extend() 或 insert()。
删除元素：例如使用 remove()、pop() 或 del。
修改元素：可以通过索引直接修改列表中的某个元素。
重新排序：例如使用 sort() 或 reverse()。
3. 内存地址不变
列表的可变性还体现在：即使修改了列表的内容，列表的内存地址（通过 id() 查看）不会改变。
示例：

my_list = [1, 2, 3]
print(id(my_list))     # 输出列表的内存地址
my_list.append(4)      # 修改列表
print(id(my_list))     # 内存地址不变


2995156144448
2995156144448

4.与不可变容器的对比

不可变容器（如元组、字符串）在创建后不能被修改。如果需要修改，实际上是创建了一个新的对象。
示例：

my_tuple = (1, 2, 3)
# my_tuple[0] = 10  # 会报错，元组不可变
new_tuple = my_tuple + (4,)  # 创建了一个新的元组
print(new_tuple)  # 输出: (1, 2, 3, 4)

特别注意，地址不变是原地修改，赋值会导致地址更改

a = [1, 2, 3]
b = [4, 5]
print(id(a))  # 输出 a 的原始地址
a = a + b     # 创建新对象并赋值给 a
print(id(a))  # 输出 a 的新地址，地址变了


2495891231040
2495891237632

5.练习题

写一个程序, 用列表保存用户输入的数据
1. 让用户输入4个任意的整数，放入列表
2. 在第三个整数前面插入一个100
3. 删除列表中的第4个整数
4. 将之前输入的第二个整数加上1 后放回原处
5. 打印现在的列表

li = []
for i in range(4):
    date = int(input('请输入四个数据'))
    li.append(date)
li.insert(2,100)
del li[3]
li[1] += 1
print(li)



请输入四个数据1
请输入四个数据2
请输入四个数据3
请输入四个数据4
[1, 3, 100, 4]

在使用extend，append注意区别。

extend将等同于: L += 可迭代对象，如列表、元组、字符串、集合等

append向列表的末尾追加单个数据

li = [1,23,2]
li2 = [1,2,3]
li.extend(li2)
print(li)



[1, 23, 2, 1, 2, 3]     #将列表的元素扩展进去

li = [1,23,2]
li2 = [1,2,3]
li.append(li2)
print(li)


[1, 23, 2, [1, 2, 3]]    #将列表作为单个元素添加进去

写程序，输入一个整数, 打印如下的四个三角形
如:
请输入: 3
1. 打印
*
**
***
2. 打印
*
**
***
3. 打印
***
**
*
4. 打印
***
**
*

n = int(input())
for i in range(1,n+1):
    print(i*'*')

for i in range(1, n + 1):
    print((n-i)*' ',end='')
    print(i * '*')

for i in range(n,0,-1):
    print(i*'*')

for i in range(n,0,-1):
    print((n-i)*' ',end='')
    print(i * '*')

写程序，输入一个整数，打印如下的正方形
如：
请输入: 4
打印:
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4

练习的时候尽量联系到所学容器实现，以及函数的调用，虽然可以通过循环的方式打印，但是通过对使用列表，可以加强对列表使用熟练度，还有理解更加深刻。

n = int(input())
li = []
for i in range(n):
    for i in range(1,n+1):
        li.append(i)
        print(li[i-1],end=' ')
    print()



4
1 2 3 4 
1 2 3 4 
1 2 3 4 
1 2 3 4

嵌套列表有点类似c语言的二维数组通过下标来遍历元素内容。

a = [1,2,3]
b = ['a','b','c']
x = [a,b]
print(x)
print(x[1])
print(x[1][2])



[[1, 2, 3], ['a', 'b', 'c']]
['a', 'b', 'c']
c

二.元组

1.为什么元组只有一个元素时要加一个逗号
单元素元组必须加逗号，以确保解释器将其识别为元组而非其他类型

t = (42)
print(type(t))  # 输出: <class 'int'>


t = (42,)
print(type(t))  # 输出: <class 'tuple'>

元组不可修改，但是可以连接组合，但是本质上是重建一个新的元组。

t =1,23,3
print(id(t))
t *=2
print(t)
print(id(t))
t += 'a','b'
print(t)


2219440096000
(1, 23, 3, 1, 23, 3)
2219439106624                    #地址改变相当于从新建造了一个元组
(1, 23, 3, 1, 23, 3, 'a', 'b')

同列表一样什么都能装，什么都能作为其元素成员，列表，元组，集合，字典。

不同之处是元组不能做任何修改，增添，删除元素（可以整体被删除），一旦做出修改，会报错。
三.字典
我的理解是字典的key为字，value是解释。字不可变，但是解释可以有多个。不可变动的有字符串，数字，元组。
字典只能通过key索引，因此可以通过遍历获取key and value

dic = {'name':'zhang','age':18}
for key in dic:
    print(key,dic[key])



name zhang
age 18

修改value时如果不存在该key，字典会自动添加key and value

```
dic = {'name':'zhang','age':18}
dic['sex'] = '男'
print(dic)



{'name': 'zhang', 'age': 18, 'sex': '男'}
```
dict.fromkeys(seq)创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值，如果未提供，则所有键的值将被设置为 None

a = ['a','b','c']
dic = dict.fromkeys(a)
print(dic)


{'a': None, 'b': None, 'c': None}

# 如果提供的 value 是不可变对象（如整数、字符串、元组等），每个键将有一个独立的值副本
new_dict['a'] = 1
print(new_dict)

# 如果提供的值是可变对象（如列表、字典等），那么所有键将共享同一个可变对象。这意味着对这个可变对象的任何修改都会反映在所有键的值上。
keys = ['a', 'b', 'c']
value = []
new_dict = dict.fromkeys(keys, value)
print(new_dict)  # 输出: {'a': [], 'b': [], 'c': []}
# 修改可变对象
new_dict['a'].append('x')
print(new_dict)  # 输出: {'a': ['x'], 'b': ['x'], 'c': ['x']}

1.练习

两个字典 dict1 和 dict2，将两个字典中所有的键值对合并，返回一个新字典

dic_name ={'a':'zhangsan','b':'lisi','c':'wangwu'}
dic_age ={'age1':12,'age2':23,'age3':23}
new_dic =dic_name.copy()
new_dic.update(dic_age)
print(new_dic)


{'a': 'zhangsan', 'b': 'lisi', 'c': 'wangwu', 'age1': 12, 'age2': 23, 'age3': 23}

假设有一个字典dict，将字典中键和值互换，生成一个新字典，如果原字典中的值有重复，则新字典中对应的键应该是这些键的列表

dic = {'a':1, 'b':2, 'c':3, 'd':1}
new_dic ={}
for key,value in dic.items():
    if value in new_dic:
        if type(new_dic[value]) is list:
            new_dic[value].append(key)
        else:
            new_dic[value]= list[new_dic[value],key]  #
    else:
        new_dic[value] = key                      #不存在key自动添加到新字典中
print(new_dic)



{1: list['a', 'd'], 2: 'b', 3: 'c'}

四.集合set/ 固定集合 frozenset

```
sentence = input("Enter a sentence: ")
se = set(sentence)
for i in se:
    print(f'{i}: {sentence.count(i)}')
print(f'你输入的句子一共{len(se)}个字符')

技: 1飞: 1。: 1了: 1人: 1众: 1开: 1的: 3智: 1
源: 1是: 1无: 1慧: 1带: 1升: 1科: 1来: 1，: 1穷: 1



你输入的句子一共19个字符
```
写程序，输入任意行文字。当没有输入的时候时结束，
将所有输入的字符串先保存在一个列表L1中 ,
将L1 中的字符串的长度都计算出来，存入列表L2 中
1）然后打印最长的字符串的字符个数
2）打印最长的那个字符串
如:
请输入: hello
请输入: abcdef
请输入: a
请输入: <直接回车结束输入>
打印：
最长的字符个数是: 5
最长的字符串是: abcdef
L1 = ['hello', 'abcdef', 'a']
L2 = [5, 6, 1]
mymax = 6 # 求出最长的字符串的长度
pos = L2.index(6) # 求出最长的字符串的位置

L1 = []
while 1 :
    sentence = input('请输入字符串')
    if sentence == '':
        break
    else:
        L1.append(sentence)
L2 = []
for i in L1:
    L2.append(len(i))
max = max(L2)
print(f'最长的字符串个数为：{max}')
index = L2.index(max)
print(f'最长的字符串是：{L1[index]}')




请输入字符串adada
请输入字符串wos
请输入字符串a
请输入字符串woaini
请输入字符串
最长的字符串个数为：6
最长的字符串是：woaini

说实话对于新手的我来说很烦躁，首先不熟悉各个函数的用法，其次是学了c语言很多东西有点不一样，要记忆的地方很多，所以边做边查找使用方法。通过做题尽快熟悉使用方法。

生成1—10之间的数字，将其平方存入list01中。将list01中所有偶数存入list02中。将list01中所有大于5的奇数增加1后存入list03中。要求都用列表推导式

list01 = [x ** 2 for x in range(1,11)]
list02 = [x for x in list01 if x % 2 == 0]
list03 = [x + 1 for x in list01 if x % 2 != 0 and x >5]
print(list01)
print(list02)
print(list03)



[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[4, 16, 36, 64, 100]
[10, 26, 50, 82]