大数据分析综合实习day03

rt_01_模拟评委打分.py

需求：模拟6位评委打分，求当前选手的最终得分
        1.键盘录入六位评委的分数，放在list列表中
        2.减去列表中的最高分和最低分
        3.求剩下四位评委的平均分作为当前选手的最终得分

#分数列表
score_list = []
#开启循环，获取六位评委的打分
for num in range(1,7):
    score = eval(input(f"请输入第{num}位评委的打分："))
    score_list.append(score)

print("六位评委的打分：",score_list )

#获取最高分
def get_max():
    #假设下标为0位置的值为最大值
    max = score_list[0]
    for score in score_list:
        if max < score:
            max = score
    return  max



#获取最低分
def get_min():
    min = score_list[0]
    for score in score_list:
        if min > score:
            min = score
    return min

#获取平均分
def get_avg():
    #减去1个最大值和最小值
    max = get_max()
    min = get_min()
    score_list.remove(max)
    score_list.remove(min)

    #求最后几个值的平均值
    sum_result = sum(score_list)
    result = sum_result / score_list.__len__()
    print(f"当前选手的最终得分是：",result)
    return result

get_avg()

输出：

rt_02__斗地主游戏.py

三个人玩斗地主
        1.获取一副扑克牌

        2.洗牌（打乱扑克顺序）
        3.三个人打斗地主（貂蝉、西施、妲己）

# 扑克
import random

card_list = []

def create_card():
    """创建一副54张的扑克"""
    color_list = ["♥","♣","♦","♠"]
    num_list = ["A","2","3","4","5","6","7","8","9","10","J","Q","K"]
    for color in color_list:
        for num in num_list:
            card_list.append(color+num)
    #追加大小王
    card_list.append("大王")
    card_list.append("小王")
    print(card_list)
    print(len(card_list))

create_card()


def shuffle_card():
    """洗牌"""
    random.shuffle(card_list)
    print(card_list)

def play_card():
    """打牌:分牌
    貂蝉：0 3 6 ...%3 == 0
    西施：1 4 7 ...%3 == 1
    妲己：2 5 8 ...%3 == 2
    """

    #留出三张底牌
    print("底牌：", card_list.pop())
    print("底牌：", card_list.pop())
    print("底牌：", card_list.pop())

    #
    dc_list = []
    dj_list = []
    xs_list = []
    for card in card_list:
        index = card_list.index(card)
        # 根据下标进行判断
        if index % 3 == 0:
            dc_list.append(card)
        elif index % 3 == 1:
            dj_list.append(card)
        elif index % 3 == 2:
            xs_list.append(card)

    print("貂蝉：", dc_list)
    print("妲己：", dj_list)
    print("西施：", xs_list)

play_card()
#for num in range(999,10000):
#   print(chr(num))

输出：

rt_03_元组.py

# 元组：可以存储多个不同数据类型的序列
# 定义：(),
# 特点：不可变的数据类型（不可以增删改）


num_tuple = (11,22,33,33,33,"小白","小黑",True)

tuple1 = tuple(range(0,10))


print(num_tuple,tuple1)
print(type(num_tuple))
print(len(num_tuple),num_tuple.__len__())


# 借助dir函数查看
print(dir(num_tuple))
# count index

# 查询
# 根据下标查元素
print(num_tuple[2])
print(num_tuple[-2])

# 根据元素查下标
print(num_tuple.index(33))


# count：统计元素在list中出现的次数
print(num_tuple.count(33))


# 注意：定义只有一个元素的元组
tuple2 = (100,)
print(tuple2)
print(type(tuple2))


# 问题：已经有了list，为什么还要使用tuple
# 各自的应用场景
# tuple:元组的元素不能被修改，保证数据的安全性
# list:比较灵活，可以增删改查
# 元组和列表之间是可以相互转换的

print(type(tuple1))
new_list = list(tuple1)
print(type(new_list),type(tuple1))

new_tuple = tuple(new_list)
print(new_tuple,type(new_tuple))

 输出：

rt_04_元组和列表之间的切片.py

# 元组和列表之间的切片

list1 = list(range(10))
print(list1)
# 根据下标操作，左闭右开
print(list1[0:3])
print(list1[:4])
print(list1[-3:])
print(list1[4:7])

# [start:stop:step]
print(list1[::2])
# 倒序
print(list1[-1::-1])

# 元组和列表的切片相同

输出：

rt_05_字典.py

# 字典：dict：可以存储多个不同数据类型序列
# 定义：{}
# 特点：字典中存储的数据是以键值对的形式存储（key-value）
# key是唯一的不能重复的，而且key是不可变数据类型

stu_info = {"name":"如花","age":"18","address":"山东泰安"}
print(stu_info,type(stu_info))
print(len(stu_info),stu_info.__len__())

# 通过dir函数查看字典中的API
print(dir(stu_info))
#  'clear', 'copy', 'fromkeys', 'get', 'items', 'keys',
#  'pop', 'popitem', 'setdefault', 'update', 'values'
# 增删改查
# 查询：只能根据key获取vale
print(stu_info['name'])
print(stu_info.get("name"))
print(stu_info.get("names"))

# 添加：根据key进行添加,如果key不存在，就是添加，如果key存在，就是修改
stu_info['classes'] = "Java"
print(stu_info)
stu_info['age'] = 19
print(stu_info)

# 更新：update，即可以添加，也可以修改
dict1 = {"name":"小明","score":"100"}
stu_info.update(dict1)
print(stu_info)

# 删除：
stu_info.pop("age")
print(stu_info)
print(stu_info.popitem())
print(stu_info)

# items,keys,values
# keys：返回字典中所有的key
print(stu_info.keys())
# values：返回字典中所有的value
print(stu_info.values())
# items：以元组的形式返回字典中所有的键值对
print(stu_info.items())

print("*"*20)
# 字典的遍历
for key in stu_info.keys():
    print(key,"--->",stu_info.get(key))
print("*"*20)
for value in stu_info.values():
    print(value)
print("*"*20)
for item in stu_info.items():
    #print(item)
    print(f"{item[0]}--->{item[1]}")

输出：

rt_06_高级数据类型的公共操作.py

# 运算符操作
# +，*，in，not in
list1 = [1,2,3]
list2 = [4,5,6]
print(list1+list2)

tuple1 = (1,2,3)
tuple2 = (4,5,6)
print(tuple1+tuple2)

# +，*：只支持字符串，列表，元组的赋值
print(list1*3)
print(tuple1*3)

# 公共方法：len,del,max,min,sum,range,enumerate

dict1 = {"name":"小明","age":"18"}
del dict1['age']
print(dict1)

print(max(list1))
print(min(tuple2))
# sum：求和运算
print(sum(list2))


# enumerate：将可迭代对象中的元素进行索引
lists = ['a','b','c','d','e']
print(enumerate(lists))

for item in enumerate(lists,start=1):
    print(item)

输出：

rt_07_推导式.py

# 推导式
# 1.list列表推导时
# 2.字典推导式
# 3.元组推导式（生成器）

# 1.list列表推导时
list1 = list(range(10))
# 对list1中的每个元素进行平方运算，获取新的列表
new_list = []
for num in list1:
    new_list.append((num**2))
print(new_list)

# 列表推导式快速实现
list2 = [num ** 2 for num in list1]
print(list2)

list3 = ["PyThon","jAva","AndroD","LiNUX"]
print(list3)
list4 = [item.title() for item in list3]
print(list4)

# 列表推导式循环嵌套
# "abc","ABC"
list5 = [s1+s2 for s1 in "abc" for s2 in "ABC"]
print(list5)

# 创建扑克牌
color_list = ["♥","♣","♦","♠"]
num_list = ["A","2","3","4","5","6","7","8","9","10","J","Q","K"]
card_list = [color+num for color in color_list for num in num_list]
print(card_list)
# 列表推导式if语句
# 求100以内的偶数和
list6 = list(range(0,101))
result = sum([num for num in list6 if num % 2 == 0])
print(result)


# 2.字典推导式
# {1:1,2:4}
dict1 = {num: num**2 for num in range(10)}
print(dict1)


key_list = ["name","age","address"]
value_list = ["李四",18,"北京海淀"]
stu_info = {key_list[num]:value_list[num] for num in range(len(key_list))}
print(stu_info)

#
comouters = {"HP":125,"DELL":201,"LENOVO":198,"HUAWEI":268}
# 过滤出电脑数量超过200的品牌

dict2 = {key:value for key,value in comouters.items() if value >= 200}
print(dict2)

输出：

rt_07_say_hello.py

def say_hello():
    print("Hello EveryOne!")

def test():
    print("Hello Test!")


print(__name__)
# 测试自己封装的函数是否有bug
if __name__ == "__main__":
    say_hello()
    test()

输出：

rt_08_模块包的操作.py

import random
import sys
# Python的模块：内置模块，自定义模块，下载的第三方模块
# 自定义模块的导入
# import关键字导入
import day03.rt_08_say_hello as sayHello
sayHello.say_hello()
sayHello.test()
sayHello.say_hello()
sayHello.test()
# from ... import *
from day03.rt_08_say_hello import *
say_hello()
test()
from day03.rt_08_say_hello import test, say_hello
test()
say_hello()

# 注意：模块命名时避免使用Python内置模块的名字
# 可以借助sys查看模块的调用顺序
print(sys.path)

输出：

rt_09_测试模块的使用.py

import day03.rt_08_say_hello as sayHello

# sayHello.tets()
sayHello.say_hello()
sayHello.test()

输出：