python第二周day2

最新推荐文章于 2024-10-02 10:53:34 发布

A16606012000

最新推荐文章于 2024-10-02 10:53:34 发布

阅读量443

点赞数

文章标签： python 算法

本文链接：https://blog.csdn.net/A16606012000/article/details/120442966

版权

python第二周day2(9.23)

1、day6列表作业更改版

import random # 随机操作
# random.randint(0, 100)
# **1.创建一个列表，列表中有10个数字, 保证列表中元素的顺序，对列表进行排重,并对列表使用进行降序排序
nums = [random.randint(95, 100) for _ in range(10)]
print('原列表：', nums) # 无序，每次结果都不一样 [96, 96, 98, 99, 95, 98, 97, 99, 96, 95]
new_nums = []
for x in nums:
    if x not in new_nums:
        new_nums.append(x)
print('去重后：', new_nums) # 去重后： [96, 98, 99, 95, 97]

new_nums.sort(reverse=True)
print('排序后：', new_nums) # 排序后： [99, 98, 97, 96, 95]
print('排序后：',sorted(new_nums, reverse=True))  # 排序后： [99, 98, 97, 96, 95]

# 2.利用列表推导式, 完成以下需求
# a. 生成一个存放1-100中个位数为3的数据列表
# 方法一
nums = [x for x in range(1, 101) if x % 10 == 3]
print(nums) # [3, 13, 23, 33, 43, 53, 63, 73, 83, 93]
# **方法二
nums = [x for x in range(3, 101, 10)]
print(nums) # [3, 13, 23, 33, 43, 53, 63, 73, 83, 93]
# nums = [x+3 for x in range(0, 90, 10)]
# print(nums)
# b. 利用列表推到是将 列表中的整数提取出来
list1 = [True, 17, "hello", "bye", 98, 34, 21]
result = [x for x in list1 if type(x) == int]
print(result) # [17, 98, 34, 21]
# c.利用列表推导式 存放指定列表中字符串的长度
list1 = ["good", "nice", "see you", "bye"]
result = [len(x) for x in list1]
print(result) # [4, 4, 7, 3]
list1 = [100, "good", "nice", "see you", "bye", 250, True]
result = [len(x) for x in list1 if type(x) == str]
print(result) # [4, 4, 7, 3]
# d. 利用列表推导式删除列表中整数个位数小于5的元素
lists = [24, 'abc', 99, True, 21, 38, 'hello']
# ['abc', 99, True, 38, 'hello']
result = [x for x in lists if not (type(x) == int and x % 10 < 5)]
print(result) # ['abc', 99, True, 38, 'hello']

# e. **利用列表推导式获取元素是元组的列表中每个元组的最后一个元素
# x = (10, 20, 30)
# print(x[-1])
lists = [(10, 20, 30), ('abc', 'hello'), (1, 2, 3.4), (True, False)]
# 先查看需要得到的结果：[30, 'hello', 3.4, False]
result = [x[-1] for x in lists ]
print(result) # [30, 'hello', 3.4, False]

# 3.已知代码如下，请回答出各个print的结果 并说明原因
# https://pythontutor.com/visualize.html#mode=edit 工具位置
nums = [17, 39, 28, 51]
nums2 = nums
nums2.pop()
print(len(nums)) # 这个结果是什么   请描述原因
# 结果：3
# 直接赋值，赋值的是地址，nums和nums2指向相同位置的地址，保存相同数据，所以对nums2改变，nums也会发生改变
# 补充：is - 是判断变量的地址是否相同 ，== - 判断两个变量对应的数据是否相同
numlist = [17, 22, 39, 58, [55, 43]]
nums3 = numlist.copy()
print(numlist is nums3)  # 结果  原因是什么
# 结果：False
# 原因是：对numlist进行复制得到nums3，是保存位置不同但数据相同的nums3，所以他们不是相等的，不是一模一样的。
numlist[-1][0] = 99  # [55, 43][0]--> 55 = 99 --> 99
print(nums3) # num3会不会发生变化
# 修改列表元素,前拷贝会发生变化。修改前面的数据不变，后面的【55，43】会发生变化
# 结果：[17, 22, 39, 58, [99, 43]]


"""
语法：
列表[下标]
说明：
列表- 是保存列表的变量或者是列表数据
"""
nums = [
    10,
    [10, 201],
    [1, 2, [1, 2]]
]
print(nums[-1][2][0]) # 1

2、元组

1.什么是元组（tuple）
“”"
元组是容器型数据类型（序列），将（）作为容器的标志里面多个元素用逗号隔开：（元素1，元素2，元素3，…）
元组不可变（不支持增删改，可以支持查）；元组是有序的（支持下标操作）
元素：任何类型的数据
“”"

t1 = (10, 20, 30)
print(t1, type(t1))  # (10, 20, 30) <class 'tuple'>
t2 = (10, 'abc', False, [10, 20])
print(t2)
t3 = ()  # 空元组
print(t3, type(t3))  # ()  <class 'tuple'>

2.元组就是不可变的列表(元组有序)
列表中除了和增，删，改相关操作以外的操作，元组都支持
例如：查，相关操作（除了增，删，改相关的），相关函数。元组不可拷贝 copy，元组不可变

t2 = (10, 23, 78, 8)
print(t2[-1]) # 8
print(t2[1:]) # (23, 78, 8)

for x in t2:
    print(x)
for index in range(len(t2)):
    print(index, t2[index])
for index, item in enumerate(t2):
    print(index, item)
print((10, 20)+(20, 30))
print((10, 20)*2)
print((1, 2, 3) == (1, 2, 3))
print((1, 2, 3) == (1, 3, 2))
print((10, 20, 30, 40) > (20, -100))
print(10 in (20, 10, 30))
# teache举例说明
num = 23
t_num = type(num)
if t_num == int or t_num == float or t_num == str:
    print('是数字或者字符串')
# **简单的书写
if t_num in (int, float, str):
    print('是数字或者字符串')  # 是数字或者字符串
t1 = (10, 20, 30)  # 元组不可拷贝 copy
print(t1.count(10))
print(t1.index(20))
print(max(t1), min(t1))
print(sum(t1))
print(sorted(t1))  # 产生一个新的列表  [10, 20, 30]
print(tuple('abc'))  # 所有序列都可以转换为元组 ('a', 'b', 'c')
print(len(t2))  # 4

3.元组特有或者常用的操作
1)只有一个元素的元组:(元素，)

list1 = [10]
print(list1, type(list1))  # [10] <class 'list'>

t1 = (10,)
print(t1, type(t1))  # (10,) <class 'tuple'>

2）元组在没有歧义的情况下可以省略（）

直接用逗号将多个数据隔开，表示的也是一个元组

t2 = (10, 23, 45, 6)
print(t2, type(t2))
t2 = 10, 23, 45, 6
print(t2, type(t2))  # (10, 23, 45, 6) <class 'tuple'>

3)同时使用多个变量获取元组的元素(列表也支持)

t2 = ('小明', 18, 90)
print(t2[0])

a.让变量的个数和元组中元素个数保持一致

name, age, score = t2
print(name, age, score)

point = (100, 200)
x, y = point
# print(x, y, z)  # 报错

b.让变量的个数小于元组元素的个数，但是必须在某一个变量前加*

先让不带的变量按照位置获取元素，剩下的部分全部保存到带的变量对应的列表中

t3 = ('小明', 18, 90, 170, 80, 76, 89, 90)
name, age, height, weight, *scores = t3
x, *y = t3
*x, y = t3

*x, y, z = t3
print(x, y, z)  # ['小明', 18, 90, 170, 80, 76] 89 90

x, y, *z = t3
print(x, y, z)  # 小明 18 [90, 170, 80, 76, 89, 90]

x, *y, z = t3
print(x, y, z)  # 小明 [18, 90, 170, 80, 76, 89] 90

t3 = ('小明', 18, 90, 170, 80, 76, 89, 90)
x, *y, z, t = t3
print(z)  # 89
print(y)  # [18, 90, 170, 80, 76]

# t4 = ['小明', 18, 90, 170, 80, 76]
# x, *y, z = t4
# print(x, y, z) # 小明 [18, 90, 170, 80] 76

3、字典（重要）

1.什么是字典（dict）
“”"
1）字典是容器型数据类型（序列），将{}作为容器的标志，里面多个键值对（元素）用逗号隔开：{键1:值1，键2:值2，…}
键值对：键：值
2）字典是可变的（支持增删改）；字典是无序的（不支持下标操作）
3）元素 - 键值对
键 - 必须是不可变的数据，例如：元组，数字，字符串。键是唯一的
值（才是真正想要保存的数据） - 没有要求

“”"

print({'a': 10, 'b': 20} == {'b': 20, 'a': 10})   #  True

1）空字典

dict1 = {}
print(dict1, type(dict1))  # {} <class 'dict'>

键是不可变的数据（类型）

dict2 = {'a': 10, 1: 20, (1, 2): 30}  #  元组
print(dict2)   # {'a': 10, 1: 20, (1, 2): 30}

# dict2 = {'a': 10, 1: 20, [1, 2]: 30} #列表
# print(dict2) #报错！！！

3)键是唯一的

dict2 = {'a': 10, 1: 20, 'a': 30}
print(dict2)  # {'a': 30, 1: 20}
# dict3 = {'a': 15, 1: 20, 'b': 90}
# print(dict3, type(dict3))  # {'a': 15, 1: 20, 'b': 90} <class 'dict'>

# 4)

4、获取字典的值

字典的查操作是获取字典的值
1.查单个
“”"
1)字典[键] - 获取字典中指定键对应的值;当键不存在的时候会报错
2)字典.get(键) ==字典.get(键,None) - 获取字典中指定键对应的值;当键不存在不会报错，返回默认值None
3)字典.get(键,默认值) - 获取字典中指定键对应的值;当键不存在不会报错，返回默认值
“”"

dog = {'name': '小黑', 'breed': '哈士奇', 'age': 3, 'color': '黑色'}
print(dog['breed'])    # 哈士奇
print(dog['color'])    # 黑色
print({'name': '小黑', 'breed': '哈士奇', 'age': 3, 'color': '黑色'}['color'])  # 黑色
print(dog.get('name'))    # 小黑
# print(dog['gender']) # 报错
print(dog.get('gender'))  # None 没有

student = {'name': '小明', 'age': 30}
print(student.get('age', 20))

2.遍历
“”"
for 遍历 in 字典：
循环体

变量取到的是键
“”"

print('---------------------------------------------------------')
dog = {'name': '小黑', 'breed': '哈士奇', 'age': 3, 'color': '黑色'}
for x in dog:
    print(x, dog[x]) # 获取的是键 name breed age color

# 用一个字典保存一个班级信息
# class1 = {
#     'name': 'Python2106',
#     'address': '9教',
#     'lecturer': {
#         'name':'陈来',
#         'age': 18,
#         'tel': '19032019876',
#         'QQ': '9087654'
#     },
#     'head_teacher':{
#         'name':'燕子',
#         'tel': '110',
#         'QQ': '721901'
#     },
#     'student':[
#         {
#          'name':'陈来',
#          'age':'10',
#          'score':98,
#          'contacts':{
#           'name':'陈真',
#           'tel':'110'
#         }},
#         {},
#         {}
#     ]
# }
class1 = {
    'name': 'Python2106',
    'address': '9教',
    'lecturer': {
        'name': '余婷',
        'age': 18,
        'tel': '13678192302',
        'QQ': '726550822'
    },
    'head_teacher': {
        'name': '张瑞燕',
        'tel': '110',
        'QQ': '7283211'
    },
    'students': [
        {
            'name': '陈来',
            'age': 20,
            'gender': '女',
            'score': 98,
            'contacts': {
                'name': 'p2',
                'tel': '120'
            }
        },
        {
            'name': '葛奕磊',
            'age': 25,
            'gender': '男',
            'score': 80,
            'contacts': {
                'name': 'p1',
                'tel': '119'
            }
        }
    ]
}
# 1.获取班级的名字
print(class1.get('name')) #Python2106
# 2.获取讲师的名字和年龄
# print(class1.get('lecturer')['name'], class1.get('lecturer')['age'])
print(class1['lecturer']['name'], class1['lecturer']['age']) # 余婷 18
lecturer = class1['lecturer']
print(lecturer['name'], lecturer['age'])
# 3.获取班主任的名字和电话
print(class1['head_teacher']['name'], class1['head_teacher']['tel']) # 张瑞燕 110
head_teacher = class1['head_teacher']
print(head_teacher['name'], head_teacher['tel'])

# **4.获取第一个学生的姓名
print(class1['students'][0]['name'])
# **5.获取所有学生的联系人的名字
for stu in class1['students']:
    print(stu['contacts']['name']) # p2,p1

# **6.计算所有学生的平均分
sum1 = 0
all_student = class1['students']
for stu in all_student:
    sum1 += stu['score']
print(sum1/len(all_student)) # 89.0

5、字典的增删改

1.增 - 添加键值对
2.改 - 修改键对应的值
语法：字典[键] = 值 - 当键存在的时候是修改，键不存在就是添加

goods = {
    'name': '泡面',
    'price': 3.5
}
print(goods)   # {'name': '泡面', 'price': 3.5}
goods['count'] = 10
print(goods)   # {'name': '泡面', 'price': 3.5, 'count': 10}
goods['price'] = 4
print(goods)

3.删

1）del 字典[键] - 删除字典中指定键对应的键值对

goods = {'name': '泡面', 'price': 3.5, 'count': 10}
del goods['price']
print(goods)  # {'name': '泡面', 'count': 10}

2）字典.pop(键) - 取出字典中指定键对应值

goods = {'name': '泡面', 'price': 3.5, 'count': 10}
new_goods = goods.pop('price')
print(goods)  # {'name': '泡面', 'count': 10}
print(new_goods) # 3.4

A16606012000

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫