python五行必备代码输出五行*,每行5个python

转载

mob64ca14079fb3 2023-10-08 14:49:27

文章标签 python五行必备代码 python 元组默认值 Python 文章分类 Python 后端开发

一、列表 list

1.1 创建列表

# 创建了一个空列表
my_list = [] 
my_list = [10,20,30,40,50]

# 通过索引获取列表中的元素
# 语法：my_list[索引]
print(my_list[4])

# 获取列表的长度，列表中元素的个数
# len()函数，通过该函数可以获取列表的长度
# 获取到的长度的值，是列表的最大索引 + 1
print(len(my_list)) # 5

1.2 切片

stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']

# 通过切片来获取指定的元素
# 语法：列表[起始:结束] 
print(stus[1:])

# 语法：列表[起始:结束:步长] 
# 步长表示，每次获取元素的间隔，默认值是1
# 如果是负数，则会从列表的后部向前边取元素
print(stus[::-1])

1.3 通用操作

# + 和 *
# +可以将两个列表拼接为一个列表
my_list = [1,2,3] + [4,5,6]

# * 可以将列表重复指定的次数
my_list = [1,2,3] * 5

stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精','沙和尚','沙和尚']
# in 和 not in
# in用来检查指定元素是否存在于列表中     如果存在，返回True，否则返回False
# not in用来检查指定元素是否不在列表中   如果不在，返回True，否则返回False
print('牛魔王' not in stus)# True
print('牛魔王' in stus)# False

# len()获取列表中的元素的个数
# min() 获取列表中的最小值
# max() 获取列表中的最大值
arr = [10,1,2,5,100,77]
print(min(arr) , max(arr),len(arr))# 1 100 6

# 两个方法（method）通过 对象.方法() 的形式调用
#xxx.index(a,b,c) a，查找的内容。  b，查找起始位置。 c，查找结束位置
#xxx.count(a) 统计指定元素在列表中出现的次数
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精','沙和尚','沙和尚']
print(stus.index('沙和尚',3,7))# 6
print(stus.count('牛魔王'))# 0

1.4 修改元素

stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']

# 直接通过索引来修改元素
stus[0] = 'sunwukong'
stus[2] = '哈哈'

# 通过del来删除元素
del stus[2] # 删除索引为2的元素

# 通过切片来修改列表
# 在给切片进行赋值时，只能使用序列
stus[0:2] = ['牛魔王','红孩儿'] #使用新的元素替换旧元素
stus[0:2] = ['牛魔王','红孩儿','二郎神']# ['牛魔王', '红孩儿', '二郎神', '沙和尚', '唐僧', '蜘蛛精', '白骨精']
stus[0:0] = ['牛魔王'] # 向索引为0的位置插入元素

# 将对应元素进行替换
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']
stus[::2] = ['牛魔王','红孩儿','二郎神'] #['牛魔王', '猪八戒', '红孩儿', '唐僧', '二郎神', '白骨精']

# 通过切片来删除元素
# del stus[0:2]
# del stus[::2]
stus[1:3] = [] # ['孙悟空', '唐僧', '蜘蛛精', '白骨精']

# 可以通过 list() 函数将其他的序列转换为list
s = list(s)

1.5 列表的方法

通过 对象.方法() 的形式调用

append（）向列表的最后添加一个元素
insert() 向列表的指定位置插入一个元素

参数：
1.要插入的位置
2.要插入的元素

extend() 使用新的序列来扩展当前序列

需要一个序列作为参数，它会将该序列中的元素添加到当前列表中

clear() 清空序列
pop() 根据索引删除并返回被删除的元素
remove() 删除指定值得元素，如果相同值得元素有多个，只会删除第一个
reverse() 反转列表
sort() 对列表中的元素进行排序，默认是升序排列

如果需要降序排列，则需要传递一个reverse=True作为参数

stus = ['孙悟空','猪八戒','沙和尚','唐僧']

# append()  向列表的最后添加一个元素
stus.append('唐僧') # ['孙悟空', '猪八戒', '唐僧', '沙和尚', '唐僧', '唐僧']

# insert()  向列表的指定位置插入一个元素
	# 参数：
	#   1.要插入的位置
	#   2.要插入的元素
stus.insert(2,'唐僧') # ['孙悟空', '猪八戒', '唐僧', '沙和尚', '唐僧']

# extend() 使用新的序列来扩展当前序列
	# 需要一个序列作为参数，它会将该序列中的元素添加到当前列表中
stus.extend(['唐僧','白骨精']) # ['孙悟空', '猪八戒', '沙和尚', '唐僧', '唐僧', '白骨精']
stus += ['唐僧','白骨精'] # ['孙悟空', '猪八戒', '沙和尚', '唐僧', '唐僧', '白骨精']

# clear() 清空序列
stus.clear()

# pop() 根据索引删除并返回被删除的元素
result = stus.pop(2) # result = 沙和尚

# remove() 删除指定值得元素，如果相同值得元素有多个，只会删除第一个
stus.remove('猪八戒')

# reverse()  反转列表
stus.reverse() # ['唐僧', '沙和尚', '猪八戒', '孙悟空']

# sort() 对列表中的元素进行排序，默认是升序排列
	# 如果需要降序排列，则需要传递一个reverse=True作为参数
my_list = list('asnbdnbasdabd')
my_list.sort() # ['a', 'a', 'a', 'b', 'b', 'b', 'd', 'd', 'd', 'n', 'n', 's', 's']
my_list.sort(reverse=True) # ['s', 's', 'n', 'n', 'd', 'd', 'd', 'b', 'b', 'b', 'a', 'a', 'a']

1.6 遍历列表

遍历列表，指的就是将列表中的所有元素取出来

stus = ['孙悟空','猪八戒','沙和尚','唐僧','白骨精','蜘蛛精']
len(stus)# 元素的个数=索引数+1

# 通过while循环来遍历列表
i = 0
while i < len(stus): #不能是 i <= len(stus),会IndexError: list index out of range
    print(stus[i])
    i += 1

# 通过for循环来遍历列表
# 语法：
#   for 变量 in 序列 :
#       代码块
for s in stus :
    print(s)

1.7 range

该函数需要三个参数
1.起始位置（可以省略，默认是0）
2.结束位置
3.步长（可以省略，默认是1）

r = range(5) # 生成一个这样的序列[0,1,2,3,4]
r = range(0,10,2)
r = range(10,0,-1)

print(type(r)) # <class 'range'>

二、元组 tuple

元组是一个不可变的序列
操作的方式基本上和列表是一致的
一般当我们希望数据不改变时，就使用元组，其余情况都使用列表

2.1 基本操作

创建
解包（解构）

# 创建元组
# 使用()来创建元组
my_tuple = () # 创建了一个空元组

# 如果元组不是空元组，它里边至少要有一个,
my_tuple = 40,
# 当元组不是空元组时，括号可以省略
my_tuple = 10,20,30,40

# 元组的解包（解构）
# 解包指就是将元组当中每一个元素都赋值给一个变量
a,b,c,d = my_tuple
print("a =",a)# a = 10
print("b =",b)# b = 20
print("c =",c)# c = 30
print("d =",d)# d = 40

# 交互a 和 b的值，这时我们就可以利用元组的解包
a , b = b , a

# 在对一个元组进行解包时，变量的数量必须和元组中的元素的数量一致
# 也可以在变量前边添加一个*，这样变量将会获取元组中所有剩余的元素
# 不能同时出现两个或以上的*变量： *a , *b , c = my_tuple SyntaxError: two starred expressions in assignment
a , b , *c = my_tuple # a = 10，b = 20，c = [30, 40]
a , *b , c = my_tuple # a = 10，b = [20, 30]，c = 40
*a , b , c = my_tuple # a = [10, 20]，b = 30，c = 40

2.2 可变对象

is ， is not 和 == ， !=

a = [1,2,3]
b = a
# == 和 != 比较的是对象的值是否相等 
# is 和 is not 比较的是对象的id是否相等（比较两个对象是否是同一个对象）
a == b # True
a is b # False

三、字典 dict

语法：

{key:value,key:value,key:value}

注意：

字典的值可以是任意对象
字典的键可以是任意的不可变对象（int、str、bool、tuple …），但是一般我们都会使用str
字典的键是不能重复的，如果出现重复的后边的会替换到前边的

3.1 基本操作

# 使用 {} 来创建字典
d = {} # 创建了一个空字典

# 使用 dict()函数来创建字典
# 每一个参数都是一个键值对，参数名就是键，参数名就是值（这种方式创建的字典，key都是字符串）
d = dict(name='孙悟空',age=18,gender='男') 

# 也可以将一个包含有双值子序列的序列转换为字典
# 双值序列，序列中只有两个值，[1,2] ('a',3) 'ab'
d = dict([('name','孙悟饭'),('age',18)])

d = {
'name':'孙悟空' , 
'age':18 , 
'gender':'男' , 
'name':'sunwukong'
}

# 需要根据键来获取值
print(d['name'],d['age'],d['gender']) # sunwukong 18 男

3.2 使用字典

获取字典的值
修改字典
get(key[, default]) 该方法用来根据键来获取字典中的值
setdefault(key[, default]) 向字典中添加key-value
update([other]) 将其他的字典中的key-value添加到当前字典中
popitem() 随机删除字典中的一个键值对，一般都会删除最后一个键值对
pop(key[, default]) 根据key删除字典中的key-value
copy() 该方法用于对字典进行浅复制

d = dict(name='孙悟空',age=18,gender='男') 

# 获取字典中的值，根据键来获取值
# 语法：d[key]
print(d['age']) # 18

# 修改字典
# d[key] = value 如果key存在则覆盖，不存在则添加
d['name'] = 'sunwukong' # 修改字典的key-value
d['address'] = '花果山' # 向字典中添加key-value

# get(key[, default]) 该方法用来根据键来获取字典中的值
#   如果获取的键在字典中不存在，会返回None
#   也可以指定一个默认值，来作为第二个参数，这样获取不到值时将会返回默认值
print(d.get('hello','默认值')) # 默认值

# setdefault(key[, default]) 向字典中添加key-value
#   如果key已经存在于字典中，则返回key的值，不会对字典做任何操作
#   如果key不存在，则向字典中添加这个key，并设置value
result = d.setdefault('name','猪八戒')
result = d.setdefault('hello','猪八戒')

# update([other]) 将其他的字典中的key-value添加到当前字典中
# 如果有重复的key，则后边的会替换到当前的
d = {'a':1,'b':2,'c':3}
d2 = {'d':4,'e':5,'f':6, 'a':7}
d.update(d2) # {'a': 7, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

# popitem() 随机删除字典中的一个键值对，一般都会删除最后一个键值对
#	无参数
#   删除之后，它会将删除的key-value作为返回值返回
#   返回的是一个元组，元组中有两个元素，第一个元素是删除的key，第二个是删除的value
# 	当使用popitem()删除一个空字典时，会抛出异常 KeyError: 'popitem(): dictionary is empty
d ={'a': 7, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
result = d.popitem() # ('f', 6)

# pop(key[, default]) 根据key删除字典中的key-value
#	会将被删除的value返回！
#	如果删除不存在的key，会抛出异常
#	如果指定了默认值，再删除不存在的key时，不会报错，而是直接返回默认值
result = d.pop('d') #('d'， 4)
result = d.pop('z','这是默认值') # 这是默认值

# copy() 该方法用于对字典进行浅复制
# 复制以后的对象，和原对象是独立，修改一个不会影响另一个
# 注意，浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制
d = {'a':{'name':'孙悟空','age':18},'b':2,'c':3}
d2 = d.copy()
d2['a']['name'] = '唐僧'
# d =  {'a': {'name': '唐僧', 'age': 18}, 'b': 2, 'c': 3} 2114569978432
# d2 =  {'a': {'name': '唐僧', 'age': 18}, 'b': 2, 'c': 3} 2114599644544

3.3 遍历字典

keys() 该方法会返回字典的所有的key
values() 该方法会返回一个序列，序列中保存有字典的左右的值
items() 该方法会返回字典中所有的项

d = {'name':'孙悟空','age':18,'gender':'男'}

# keys()来获取所有的键
for k in d.keys() :
    print(k , d[k])
# name 孙悟空
# age 18
# gender 男

# values()  该方法会返回一个序列，序列中保存有字典的左右的值
for v in d.values():
    print(v)
# 孙悟空
# 18
# 男

# items()   该方法会返回字典中所有的项
# 它会返回一个序列，序列中包含有双值子序列
print(d.items()) # dict_items([('name', '孙悟空'), ('age', 18), ('gender', '男')])
for k,v in d.items() :
    print(k , '=' , v)
# name = 孙悟空
# age = 18
# gender = 男

四、集合 set

4.1 基本操作

创建集合
add() 向集合中添加元素
update() 将一个集合中的元素添加到当前集合中
pop() 随机删除并返回一个集合中的元素
remove()删除集合中的指定元素
copy()对集合进行浅复制

# 使用 {} 来创建集合
s = {10,3,5,1,2,1,2,3,1,1,1,1} # <class 'set'>  
# 使用 set() 函数来创建集合
s = set() # 空集合
# 可以通过set()来将序列和字典转换为集合
s = set([1,2,3,4,5,1,1,2,3,4,5])
# 使用set()将字典转换为集合时，只会包含字典中的键
s = set({'a':1,'b':2,'c':3}) 

# add() 向集合中添加元素
s.add(10)

# update() 将一个集合中的元素添加到当前集合中
#   update()可以传递序列或字典作为参数，字典只会使用键
s.update({10:'ab',20:'bc',100:'cd',1000:'ef'})

# pop() 随机删除并返回一个集合中的元素
result = s.pop()

# remove()删除集合中的指定元素
s.remove(100)

# copy()对集合进行浅复制
s.copy()

4.2 集合运算

& 交集运算
| 并集运算

差集
^ 异或集获取只在一个集合中出现的元素
-子集与真子集

<= 检查一个集合是否是另一个集合的子集
< 检查一个集合是否是另一个集合的真子集
>= 检查一个集合是否是另一个的超集
> 检查一个集合是否是另一个的真超集

s = {1,2,3,4,5}
s2 = {3,4,5,6,7}

# & 交集运算
result = s & s2 # {3, 4, 5}

# | 并集运算
result = s | s2 # {1,2,3,4,5,6,7}

# - 差集
result = s - s2 # {1, 2}

# ^ 异或集 获取只在一个集合中出现的元素
result = s ^ s2 # {1, 2, 6, 7}

# <= 检查一个集合是否是另一个集合的子集
# 如果a集合中的元素全部都在b集合中出现，那么a集合就是b集合的子集，b集合是a集合超集
a = {1,2,3}
b = {1,2,3,4,5}
result = a <= b # True
result = {1,2,3} <= {1,2,3} # True
result = {1,2,3,4,5} <= {1,2,3} # False

# < 检查一个集合是否是另一个集合的真子集
# 如果超集b中含有子集a中所有元素，并且b中还有a中没有的元素，则b就是a的真超集，a是b的真子集
result = {1,2,3} < {1,2,3} # False
result = {1,2,3} < {1,2,3,4,5} # True

# >= 检查一个集合是否是另一个的超集
# > 检查一个集合是否是另一个的真超集

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：Wireshark如何按照mysql协议解析报文利用wireshark进行协议分析

下一篇：Android打包时的keystore有什么用 apk打包是什么意思

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

python五行必备代码输出五行*,每行5个python

python五行必备代码输出五行*,每行5个python

目录

一、列表 list

1.1 创建列表

1.2 切片

1.3 通用操作

1.4 修改元素

1.5 列表的方法

1.6 遍历列表

1.7 range

二、元组 tuple

2.1 基本操作

2.2 可变对象

三、字典 dict

3.1 基本操作

3.2 使用字典

3.3 遍历字典

四、集合 set

4.1 基本操作

4.2 集合运算

51CTO博客

python五行必备代码 输出五行*,每行5个python

python五行必备代码 输出五行*,每行5个python

目录

一、列表 list

1.1 创建列表

1.2 切片

1.3 通用操作

1.4 修改元素

1.5 列表的方法

1.6 遍历列表

1.7 range

二、元组 tuple

2.1 基本操作

2.2 可变对象

三、字典 dict

3.1 基本操作

3.2 使用字典

3.3 遍历字典

四、集合 set

4.1 基本操作

4.2 集合运算

51CTO博客

python五行必备代码输出五行*,每行5个python

python五行必备代码输出五行*,每行5个python