name_list = ["张三", "李四", "王五", "王小二", "张三", "张三"]
# len(length 长度) 函数可以统计列表中元素的总数
list_len = len(name_list)
print("列表中包含"+str(list_len)+"个元素")
# count 方法可以统计列表中某一个数据出现的次数
count = name_list.count("张三")
print("张三出现了"+str(count)+"次")
# 从列表中删除第一次出现的数据,如果数据不存在,程序会报错
name_list.remove("张三")
name_list = ["zhangsan", "lisi", "wangwu", "wangxiaoer"]
num_list = [6, 8, 4, 1, 10]
# 升序
name_list.sort() # 按首字母排序
num_list.sort() # 从小到大
# 降序
name_list.sort(reverse=True)
num_list.sort(reverse=True)
# # 逆序(反转)
print(name_list.reverse())
print(num_list.reverse())
for item in name_list:
print(item)
for i in num_list:
print(i)
先举个栗子:实现列表正向删除操作
list01 = [1, 2, 3, 4, 5, 6, 7, 8]
# 列表正向的弊端
# 首先判断1<5,将1删除,之后列表变成[2,3,4,5,6,7,8],即且数据整体向前迁移一位
# 第二步判断的不是2,而是3,3< 5将3删除,之后列表变成[2,4,5,6,7,8]
# 第三步判断的不是4,而是5,5=5,不删除,输出5
for i in list01:
if i<4:
list01.remove(i)
print(list01)
原始列表
list01 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
---|---|---|---|---|---|---|---|---|
索引 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
首先判断1<5,将1删除,之后列表变成[2,3,4,5,6,7,8],即且数据整体向前迁移一位
list01 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
---|---|---|---|---|---|---|---|
索引 | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
第二步判断的不是2,而是3,3< 5将3删除,之后列表变成[2,4,5,6,7,8]
list01 | 2 | 4 | 5 | 6 | 7 | 8 |
---|---|---|---|---|---|---|
索引 | 0 | 1 | 2 | 3 | 4 | 5 |
第三步判断的不是4,而是5,5=5,不删除,输出5
以上要细品、一定要细品!!
既然正向不行了,那我们就倒叙删除吧
list01 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 删除元素方法有两种:
# 1、用倒序的方法删除,防止值自动补位
for i in range(len(list01)-1,-1,-1):
if list01[i]%2:
# 删除语法一:
# list01.pop(i)
# 删除语法二:
del list01[i]
print(list01)
# 2、正向通过索引删除值(enumerate比较高级暂时未学到此知识点【慎用】)
for index,value in enumerate(list01):
if list01[index]%2:
# 删除语法一:
list01.pop(index)
# 删除语法二:
# del list01[index]
# 删除语法三:
# list01.remove(value)
print(list01)
lenght = int(input("请输入斐波那契数列长度:"))
# 如长度为6
fib= [1,1]
for __ in range(lenght - 2):
# 当前元素 = 最后两个元素之和
element = fib[-2] + fib[-1]
fib.append(element)
print(fib)
list01 = [2, 9, 40, 16, 57, 38]
max_value = list01[0]
for i in range(1, len(list01)):
if max_value < list01[i]:
max_value = list01[i]
print("最大值:",max_value)
浅拷贝:是在复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程。
深拷贝:复制整个依懒的变量。
info_tuple = ("zhangsan", 18, 1.75)
info_tuple = ()
info_tuple = (50, )
info.count info.index
有关元组的常用操作可以参照上图练习
# for 循环内部使用的变量 in 元组
for item in info:
循环内部针对元组元素进行操作
print(item)
# 通过索引
t03=(1,2,3,4)
正向
for index in range(len(t03)):
print(t03[index],end="") #1234
print("")
反向
for index in range(len(t03)-1,-1,-1):
print(t03[index],end="") #4321
- 在Python中,可以使用for循环遍历所有非数字型类型的变量:列表、元组、字典以及字符串
- 提示:在实际开发中,除非能够确认元组中的数据类型,否则针对元组的循环遍历需求并不是很多
info = ("zhangsan", 18)
print("%s 的年龄是 %d" % info)
list(元组)
tuple(列表)
list01 = [25, 89, 32, 15, 23, 66]
tuple01 = (25, 89, 32, 15, 23, 66)
print("元组转列表",list(tuple01))
print("列表转元组",tuple(list01))
元组与列表都可以存储一系列变量,由于列表会预留内存空间,所以可以增加元素。
元组会按需分配内存,所以如果变量数量固定,建议使用元组,因为占用空间更小。
列表(可变):预留空间
元组(只读):按需分配
xiaoming = {"name": "小明",
"age": 18,
"gender": True,
"height": 1.75}
In [1]: xiaoming.
xiaoming.clear xiaoming.items xiaoming.setdefault
xiaoming.copy xiaoming.keys xiaoming.update
xiaoming.fromkeys xiaoming.pop xiaoming.values
xiaoming.get xiaoming.popitem
有关字典的常用操作可以参照上图练习
dict01 = {1001:"王宝强",1002:"马蓉",1005:"宋喆"}
# 1. 添加
# --通过键-值
dict01[1003] = "文章"
# 2. 修改(如果key存在,则为修改,不存在则为添加)
dict01[1002] = "伊利"
# 3. 删除
# 如果key不存在则报错
if 1001 in dict01:
del dict01[1001]
# 4. 查询
# key/循环
print(dict01[1005])
# for 循环内部使用的 `key 的变量` in 字典
for k in xiaoming:
print("%s: %s" % (k, xiaoming[k]))
提示:在实际开发中,由于字典中每一个键值对保存数据的类型是不同的,所以针对字典的循环遍历需求并不是很多
dict01 = {1001:"王宝强",1002:"马蓉",1005:"宋喆"}
# -- 获取所有key # 1001 1002 1005
for key in dict01:
print(key)
# --获取所有value # 王宝强 马蓉 宋喆
for value in dict01.values():
print(value)
# --获取所有key - value # 1001 王宝强 1002 马蓉 1005 宋喆
for key,value in dict01.items():
print(key)
print(value)
card_list = [{"name": "张三",
"qq": "12345",
"phone": "110"},
{"name": "李四",
"qq": "54321",
"phone": "10086"}
]
stu01 = {1001:"王宝强",1002:"马蓉",1005:"宋喆"}
stu02 = dict(["宝强",(125,"马小荣"),[234,"宋喆"]])
list01 = list(stu01)
print(stu02)
print(list01)
集合名 = set()
集合名 = set(可迭代对象)
集合名 = {1, 2, 3}
集合名 = set(可迭代对象)
添加元素:集合名.add(元素)
update()方法用于修改当前集合,可以添加新的元素或集合到当前集合中,如果添加的元素在集合中已存在,则该元素只会出现一次,重复的会忽略。
set2={"a", 2, "b", 3, "d"}
set1 = {"a", 2, "b", 3, "e"}
set2.update(set1)
print(set2)#{2, 3, 'd', 'b', 'a', 'e'}
1 交集&:返回共同元素。
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 & s2 # {2, 3}
2 并集 |:返回不重复元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 | s2 # {1, 2, 3, 4}
3 补集-:返回只属于其中之一的元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 - s2 # {1} 属于s1但不属于s2
s2 - s1 # {4} 属于s2但不属于s1
4 补集^:返回不同的的元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 ^ s2 # {1, 4} 等同于(s1-s2 | s2-s1)
子集<:判断一个集合的所有元素是否完全在另一个集合中
超集>:判断一个集合是否具有另一个集合的所有元素
s1 = {1, 2, 3}
s2 = {2, 3}
s2 < s1 # True
s1 > s2 # True
相同或不同== !=:判断集合中的所有元素是否和另一个集合相同。
s1 = {1, 2, 3}
s2 = {3, 2, 1}
s1 == s2 # True
s1 != s2 # False
子集或相同,超集或相同 <= >=
定义:使用简易方法,将可迭代对象转换为集合。
语法:
{表达式 for 变量 in 可迭代对象}
{表达式 for 变量 in 可迭代对象 if 条件}
固定集合 frozenset
定义:不可变的集合。
作用:固定集合可以作为字典的键,还可以作为集合的值。
基础操作:创建固定集合:frozenset(可迭代对象)
运算:等同于set