2023.10.8-python学习,数据容器习题,函数类型

一.数据容器

1.序列删除元素操作remove

'''
给定一个列表，首先删除以s开头的元素，

删除后，修改第一个元素为"joke"，

并且把最后一个元素复制一份，放在joke的后边
'''
my_list = ["spring", "strange", "look",
           "curious", "black", "hope"]
# 删除以s开头的元素
for i in my_list[:]:
    if i[0] == 's':
        my_list.remove(i)
print(my_list)

for i in my_list:
    if i.startswith('s'):
        my_list.remove(i)
print(my_list)

'''按照索引来删除remove,但remove移除后索引都会变,会有遗漏的移除项,
如果把两个s开头的字母放在前两个位置,只会移除第一个单词
,第二个不会,因为for循环记录的是原本的索引位置,不判断已经进行过判断的索引位置
在要循环的列表后面加一个[:],表示每次循环都从头判断到尾
'''

 2.序列删除元素操作startwith

print('---------------------------------------------')
my_list = ["spring", "strange", "look",
           "curious", "black", "hope"]
i = 0
while i < len(my_list):
    if my_list[i].startswith('s'):
        my_list.remove(my_list[i])
    i += 1
print(my_list)
# ['strange', 'look', 'curious', 'black', 'hope']
print('---------------------------------------------')

 3.往字典添加键值对

d1 = {}
d1[5] = 10
d1[6] = 11
d1['5'] = 12
d1[5.0] = 13
print(d1)

# key重复,后面新增的value直接替换原先的,5.0被认为等于5

 {5: 13, 6: 11, '5': 12}

 4.容器通用操作,len,max,min,sored,reverse,enumerate

list_1 = ['d', 'a', 'b', 'c', 'e']
tuple_1 = ('d', 'a', 'b', 'c', 'e')
str_1 = 'abcde'
set_1 = {'d', 'a', 'b', 'c', 'e'}
dict_1 = {'d': 1, 'a': 1, 'b': 1, 'c': 1, 'e': 1}

print('-----------求长度---------------')
print(len(list_1))  #5
print('-----------求最大---------------')
print(max(list_1))  # e
print('-----------求最小---------------')
print(min(list_1))  # a
print(min(dict_1))  # a
print('-----------排序---------------')
print(sorted(list_1))  #['a', 'b', 'c', 'd', 'e']
print(sorted(set_1))  # ['a', 'b', 'c', 'd', 'e']
# ['a', 'b', 'c', 'd', 'e'],默认从小到大排序,并放到列表中
print('-----------翻转---------------')
print(sorted(list_1))  # ['a', 'b', 'c', 'd', 'e']

print(sorted(list_1, reverse=False))  # 默认从小到大,假的反转
# ['a', 'b', 'c', 'd', 'e']
print(sorted(list_1, reverse=True))  # 默认从小到大,真的反转
# ['e', 'd', 'c', 'b', 'a']

print('-----------枚举---------------')
for i, e in enumerate(list_1):
    print(i, e)
'''
0 d
1 a
2 b
3 c
4 e
'''

print('--------------枚举循环----------------')
sum = 0
num = 0
for i in range(101):  # 0,101(不包含101),1
    sum = num + sum
    num += 1
    a = (sum, num)
for q, e in enumerate(a):
    print(q, e)
'''
0 5050
1 101
'''

5.容器强转换类型,eval去引号

print('----------容器强转换类型-----------------')
# 利用集合的去重特点来去重
list_5 = [1, 2, 3, 4, 5, 4, 3, 2, 1]
set_2 = set(list_5)
print(set_2)
# {1, 2, 3, 4, 5}

list_2 = ['d', 'a', 'b', 'c', 'e']
tuple_1 = ('d', 'a', 'b', 'c', 'e')
str_1 = 'abcde'
set_1 = {'d', 'a', 'b', 'c', 'e'}
dict_1 = {'d': 1, 'a': 1, 'b': 1, 'c': 1, 'e': 1}

s1 = str(list_2)
print(s1)
# 把列表转换为字符串['d', 'a', 'b', 'c', 'e']

s2 = list(s1)
print(s2)
'''把列表转为字符串后,再把这个字符串转回列表,
会把所有的字符都当成列表里的元素,从而数据错乱,
比如['[', "'", 'd', "'", ',', ' ', "'", 'a', "'"
'''

print(eval(s1), type(list_2))
# ['d', 'a', 'b', 'c', 'e'] <class 'list'>
'''用eval函数去掉引号要注意,会把普通的字符串的引号也去掉,变得啥也不是
比如print(eval('白')),也容易把原本的字符串类型转换成其他的数据类型'''
print(eval('3.14'), type(eval('3.14')))
# 字符串去掉了引号变成浮点数类型
print(eval('True'), type(eval('True')))
# 字符串去掉了引号变成了布尔类型
print(eval('10'), type(eval('10')))
# 字符串去掉了引号变成了整数类型

6.三大序列通用符号 

+ : 通用拼接符号 ,产生新的序列

* : 通用复制拼接符号,产生新的序列

# 定义列表
list1 = ['d', 'a', 'b', 'c', 'e']
# 定义元组
tuple1 = ('d', 'a', 'b', 'c', 'e')
# 定义字符串
str1 = 'dabce'

# 演示通用拼接符号:+  产生新的序列
print(list1 + ['f'])
print(tuple1 + ('f',))
print(str1 + 'f')

# 演示通用复制拼接符号: * 产生新的序列
print(list1 * 3)
print(tuple1 * 3)
print(str1 * 3)

7.给变量赋值

'''两个变量交换值,把a和b的值交换'''
a = 10
b = 20
print(a, b)  # 10,20
temp = a  # 把10给t
a = b  # 把20给a
b = temp  # 把t10 给b 
print(a, b)

a = 10
b = 20
b, a = a, b
print(a, b)  # 20 10

 二.函数

 1.函数多个返回值

#  先定义函数
def show():
    return 1, 2, 3


# 函数返回多个值,核心思想是放到容器中返回,默认用的元组

# 再调用函数
result = show()
print(result, type(result))
# 接收后的result ,被变成了元组,把他拆出来,可以用循环
for i in result:
    print(i)
# 定义n个值来接收拆包后的元组里的元素
a, b, c = show()
print(a, b, c)

 2.位置参数

print('--------------位置参数----------------------')


def user_info(name, age, gender):
    print(f'您的名字是{name},年龄是{age},性别是{gender}')


# 位置参数,调用函数时根据函数定义的参数位置来传递参数
user_info('白', 20, '男')  # 您的名字是白,年龄是20,性别是男
user_info('黒', 30, '女')  # 您的名字是黒,年龄是30,性别是女

 3.关键字参数

print('--------------关键字传参----------------------')


def user_info(name, age, gender):
    print(f'您的名字是:{name},年龄是:{age},性别是:{gender}')


# 关键字参数,函数调用时通过“键=值”形式传递参数
user_info(name='张三', age='19', gender='男')

# 顺序可以打乱
user_info(gender='男', name='张三', age='19')
# 函数调用时，如果有位置参数时，
# 位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
user_info('张三', '19', gender='男')


def keyword(name, sex, hobby):
    print(f'您的名字是{name},您的性别是{sex},您的爱好是{hobby}')


keyword(name='白', sex='男', hobby='运动')


def keyworld(a, b, c):
    d = (a + b) / c
    e = (a * b) + c
    return d, e


f = keyworld(c=1, a=20, b=10)
print(f)

 4.缺省参数

 调用的时候叫关键字参数,定义的时候叫缺省参数,

如果设置的时候都设置了缺省参数,调用的时候只想改变后面的某个数据,需要用关键字参数

print('----------------缺省参数-----------------------')


# 缺省参数：缺省参数也叫默认参数，用于定义函数，解决了实参和形参数量不一致的问题,
# 为参数提供默认值，调用函数时可不传该默认参数的值
# （注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）.

def user_info(name, age, gender='男'):
    # 如果调用的函数没有输入性别,就默认是男的
    print(f'您的名字是:{name},年龄是:{age},性别是:{gender}')


user_info('张三', 20)  # 您的名字是:张三,年龄是:20,性别是:男
user_info('王五', 20, '女')  # 您的名字是:王五,年龄是:20,性别是:女


def keyw(name, sex='男', hobby='打篮球'):
    print(f'您的名字是{name},您的性别是{sex},您的爱好是{hobby}')


keyw(name='白', sex='男')
keyw('黑', '女', '足球')  # 主动传入了参数,将以传入的参数为主

'''

您的名字是白,您的性别是男,您的爱好是打篮球
您的名字是黑,您的性别是女,您的爱好是足球

'''

 5.不定长参数

print('------------------不定长参数-----------------------')

# 不定长参数,不定长参数：不定长参数也叫可变参数.
# 用于不确定调用的时候会传递多少个参数(不传参也可以)的场景.
'''
可变参数:不定长参数
位置传参数:一个个数据,使用*args接收,默认把数据存储到了元组
关键字传参,一对对数据,使用**kwargs,默认把数据存储到字典
'''


def user_info(*args):
    print(args)


user_info('张三')
user_info('李四', 18)


def user_info(**kwargs):
    print(kwargs)


user_info(name='张三', age=18, gender='女')


# {'name': '张三', 'age': 18, 'gender': '女'}

def show2(*args):
    print(args)


show2(1, 2)


def show2(*args, **kwargs):
    print(args)
    print(kwargs)
    print(type(kwargs))


show2(3, 4, a=4, b=5, c=6)
#  {'a': 4, 'b': 5, 'c': 6},<class 'dict'>

 6.调用参数时,位置参数一定要在最前面

'''定义函数顺序要求
位置参数放最前面-关键字参数-不定长参数也可以作为位置参数
'''

'''定义一个求和的参数'''
def sum_get(*args, **kwargs):
    sum_1 = 0
    for i in args:
        sum_1 += i
    return sum_1


a = sum_get(1, 2, 3, 4, 5)
print(a)

 双击字符,在点击键盘上的引号,可以直接给字符添加

7.利用不定长参数,定义一个可以给多个参数求和的参数 

'''定义一个求和的参数'''


def sum_get(*args, **kwargs):
    sum_1 = 0
    for i in args:  # 把输入的实际参数遍历
        sum_1 += i
    return sum_1


a = sum_get(1, 2, 3, 4, 5)
print(a)