5.列表，元组介绍

1.相关函数

1.max,min - 最大值，最小值

max(序列)
nums=[34,44,78,56,90,23]
print(max(nums),min(nums))

2.sum - 求数字序列中元素的和

# sum(序列)
print(sum(nums))

3.sorted - 排序;不修改原序列中元素的序列而是产生一个新的列表

sorted(序列);sorted(序列，reverse= TRUE)
nums=[34,44,78,56,90,23]
new_nums = sorted(nums)
print(new_nums)
print(nums)

# 列表.sort();列表.sort(reverse= True)
nums=[34,44,78,56,90,23]
result= nums.sort()
print(nums)
print(result) #none 没有用

4.len - 获取序列中元素的个数

5.list - 列表转换

# list（序列）  - 所有的序列都可以转换成列表；转换的饿时候直接将序列中的元素转换成列表的元素
print(list('abc'))      #['a', 'b', 'c']
print(list(range(6)))   #[0, 1, 2, 3, 4, 5]

2.列表推导式

1.本质是创建列表的表达式

"""
结构一：
[表达式 for 变量 in 序列]

结构一：
[表达式 for 变量 in 序列 if 条件语句]
"""
list1 = [20 for  x in range(4)]
print(list1)    #[20, 20, 20, 20]

list2 = [x for x in range(3)]
print(list2)    #[0, 1, 2]

list3 = [x*2+1 for x in range(5)]
print(list3)    #[1, 3, 5, 7, 9]

2.推导式的应用

"""
应用1： 让序列中所有的元素进行统一变换
[表达式 for 变量 in 序列]

应用2：将序列中满足某个条件的元素进行变换（根据某个条件是否满足做两种不同的选择）
[表达式1 if 条件语句 else 表达式2 for x in 序列]

应用3：提取序列中满足某个条件的元素(提取,删除)
[表达式 for 变量 in 序列]
"""
# [89,67,43,56,10,90] -> [[0,89] [1,67],...]
nums = [89, 67, 34, 56, 10, 90]
new_nums=[[x,nums[x]] for x in range(len(nums))]
print(new_nums)

# 将num中所有的偶数除以2
# [89, 67, 34, 56, 10, 90, 35] -> [89, 67, 17, 28, 5, 45, 35]

nums = [89, 67, 34, 56, 10, 90, 35]
new_nums= [x//2 for x in nums if x%2==0]
print(new_nums)

new_nums=[x if x % 2 else x//2 for x in nums]
print(new_nums)

# 练习2：删除所有的偶数（提取所有的奇数）
# [89, 67, 34, 56, 10, 90, 35] -> [89, 67, 35]
nums = [89, 67, 34, 56, 10, 90, 35]
new_nums = [x for x in nums if x % 2]
print(new_nums)

3.三目运算符

# 双目运算符： + - * ... > =
# 单目运算符：not
# 三目运算符：

# 1.c/java语言的三目运算符： ？ ：

"""
条件语句？ 表打死1：表达式2     - 如果条件语句成立整个运算结果是表达式1的值，否则整个运算结果表达式2的值
"""

2.python的三目运算符

"""
表达式1 if 条件语句 else 表达式2  - 如果条件语句成立整个运算结果是表达式1的值，否则整个运算表达式2的值

"""
age= 38
# if age >=18

a = '成年' if age >=18 else '未成年'
print(a)

4.元组

1.什么元组(tuple)

"""
元组是容器型数据类型,将（）作为容器的标志,里面多个元素用逗号隔开：（元素1，元素2，元素3）
元组不可变(只能查);元组有序-支持下标操作
元素：和列表一样
"""
# 1)空元组
t1=()
print(type(t1),len(t1))

# 2)只有一个元素的元组 - 唯一的元素后面必须加逗号
list1 = [12]
print(list1,type(list1),len(list1))

t2 = (12)
print(t2,type(t2))  # 12,class int

t3 = (12,)
print(t3,type(t3))  #(12,) <class tuple>
# 3)普通情况
t4=(10,34,78)
print(t4)

# 4)在没有歧义的情况下,元组的小括号可以省略(直接多个数据用逗号隔开表示的也是一个元组)
t5 = 10,34,78
print(t5,type(t5))

t6= 10,34,78*2
print(t6,type(t6))

2.查 -获取元素

# 1)列表获取元素的方式元组都支持
nums= (23,45,90,78,6,34)
print('===================')
print(nums[1],nums[-5])
for x in nums:
    print(x)
print('============================')
for index in range(len(nums)):
    print(index,nums[index])

print('=====================================')
#for index,item in

# 2)通过变量获取元组的元素1    -
point= (10,23,12)
x,y,z=point
print(x,y,z)

# 3)通过变量获取元组的元素2 -
# 如果变量的个数小于元素的个数,那么必须在其中一个变量前加*,取的时候先让没有*变量按照位置关系,
#获取元素,剩下的全部给带*的变量（以列表的形似）
info=('张三',12,175,180,90,67,89)
name,age,*other = info
print(name,age,other) #张三 12 [175, 180, 90, 67, 89]

name,*other=info
print(name,other) #张三 [12, 175, 180, 90, 67, 89]

name,age,*other,math = info
print(name,age,math)    #张三 12 89

3. 元组是不可变的列表 - 列表中不可变相关操作元组都支持

   # # +、*
   # # in 和not in
   # # 比较运算
   # # 元组.count()\元组.index()
   # # max\min\sum\sorted\len\tuple
   

5.字典

1.字典的作用-同时保存多个意义不同的数据

stu ={
    'name':'小明',
    'age':20,
    'weight':'男',
    '体重':60,
    'math':89,
    '语文' :70,
}
print(stu['name'])

2.什么是字典 (dict)

"""
字典是容器型的数据类型:将{}作为容器标志,里面多个键值对用逗号隔开: #{键：值1，键2：值2，....}
字典是可变的（支持增删改）;字典是无序（不支持下标操作）

元素的要求：字典元素是键值对
    键   - 键必须是不可变的数据（例如：数字、字符串、元组）；键是唯一的；
    值   - 没有要求
"""
# 1）空字典：{}
d1={}
print(type(d1),len(d1),bool(d1))    # <class 'dict'> 0 False

# 2)键是不可变的数据
d2={1:10,"a":20,(10,20):30}
print(d2)

# d3={1:10,"a":20,[10,20]:30} # 报错

# 3)键是唯一的
d4={'a':10,'b':20,'c':30,'b':40}    # {'a': 10, 'b': 40, 'c': 30}
print(d4)

# 4) 字典是无序的
print({'a':10,'b':20}=={'b':20,'a':10}) # true

# 5) 字典的增删改查
# 1）查   -   获取字典的值
# a.获取单个值
'''
字典[键]   - 获取字典中键对应的值,如果键不存在程序报错！
字典.get(键)/字典.get(键.默认值)   - 获取字典中指定键对应的值，如果键不存在返回None或者返回默认值
'''
dog={ 'name':'菜菜','age':3,'breed':'土狗'}
print(dog['name'])
print(dog['age'])
print(dog['breed'])

print(dog.get('height',0))

# b.遍历
# 通过for循环遍历字典的时候,循环变量依次取到的是字典的键
'''
for 变量 in 字典： 键英文翻译：key
    循环体
'''
print('-----------------------------------')
# for key in dog:
#    print(key,dog[key])

3.实际应用中的字典和列表

# 定义一个保存一个班级信息

class1 = {
    'name': 'python2104',
    'address': '23教',
    'lecturer': {'name': '余婷', 'age': 18, 'QQ': '726550822'},
    'leader': {'name': '舒玲', 'age': 18, 'QQ': '2343844', 'tel': '110'},
    'students': [
        {'name': 'stu1', 'school': '清华大学', 'tel': '1123', 'linkman': {'name': '张三', 'tel': '923'}},
        {'name': 'stu2', 'school': '攀枝花学院', 'tel': '8999', 'linkman': {'name': '李四', 'tel': '902'}},
        {'name': 'stu3', 'school': '成都理工大学', 'tel': '678', 'linkman': {'name': '小明', 'tel': '1123'}},
        {'name': 'stu4', 'school': '四川大学', 'tel': '9900', 'linkman': {'name': '小花', 'tel': '782'}},
        {'name': 'stu5', 'school': '西南交大', 'tel': '665', 'linkman': {'name': '老王', 'tel': '009'}}
    ]

}

# 1）获取班级名称
# 2）获取讲师QQ
# 3）获取所有学生的名字和学校
# 4）获取所有学生的联系人的电话
# 1）
print(class1['name'])
# 2）
print(class1['lecturer']['QQ'])
# 3)
for stu in class1['students']:
    print(stu['name'],stu['school'])
# 4）获取所有学生的联系人的电话

for stu in class1['students']:
    print(stu['linkman']['tel'])

6.课后作业

1.已知一个数字列表，求列表中心元素。

# 1.已知一个数字列表，求列表中心元素。
# 7  ->  3
# 5  ->  2
# 9  ->  4
# N  ->  长度 // 2
# 8  ->  3, 4
# 6  ->  2, 3
# N  ->  N/2 - 1, N/2
# 语法： 列表[下标]

nums = [23, 45, 89, 20, 19, 40, 30, 8]
count = len(nums)
if count % 2:
    print(nums[count // 2])
else:
    index = count // 2
    print(nums[index - 1], nums[index])

2.已知一个数字列表，求所有元素和。

nums = [23, 45, 89, 20, 19, 40, 30, 8]
sum1 = 0
for item in nums:
    sum1 += item
print(sum1)

3.已知一个数字列表，输出所有奇数下标元素。

nums = [23, 45, 89, 20, 19, 40, 30, 8]
print(nums[1::2])

4.已知一个数字列表，输出所有元素中，值为奇数的元素。

nums = [23, 45, 89, 20, 19, 40, 30, 8]
for item in nums:
    if item % 2:
        print(item)

5.已知一个数字列表，将所有元素乘二。

例如：nums = [1, 2, 3, 4] —> nums = [2, 4, 6, 8]

# 方法一：
# 列表[下标] = 值
nums = [23, 45, 89, 20, 19, 40, 30, 8]
for index, item in enumerate(nums):
    nums[index] = item * 2
print(nums)

# 方法二：
nums = [23, 45, 89, 20, 19, 40, 30, 8]
new_nums = []
for item in nums:
    new_nums.append(item * 2)
print(new_nums)

6.有一个长度是10的列表，数组内有10个人名，要求去掉重复的

例如:names = [‘张三’, ‘李四’, ‘大黄’, ‘大黄’, ‘张三’, ‘张三’, ‘张三’] -> names = [‘张三’, ‘李四’, ‘大黄’]

names = ['张三', '李四', '大黄', '大黄', '张三', '张三', '张三']
# 方法一：
new_names = []
for name in names:
    if name not in new_names:
        new_names.append(name)
print(new_names)

# 方法二：
names = ['hello', 'hello', 'chat', 'baby', 'maybe', 'hello', 'baby', 'hello', 'chat', 'maybe', 'hello']
for item in names.copy():
    if names.count(item) >= 2:
        names.remove(item)
print(names)

7.用一个列表来保存一个节目的所有分数，求平均分数(去掉一个最高分，去掉一个最低分，求最后得分)

print('------------------第7题----------------------')
scores = [89, 90, 65, 70, 92, 88, 56]
# 方法一：
scores.sort()
sum1 = 0
del scores[0]
del scores[-1]
for i in scores:
    sum1 += i
print(sum1 / len(scores))

# 方法二：
scores = [89, 90, 65, 70, 92, 88, 56]
max_score = min_score = scores[0]
sum1 = 0
for item in scores:
    if item > max_score:
        max_score = item
    elif item < min_score:
        min_score = item
    sum1 += item

print((sum1 - max_score - min_score) / (len(scores) - 2))

8.有两个列表A和B，使用列表C来获取两个列表中公共的元素

例如: A = [1, ‘a’, 4, 90] B = [‘a’, 8, ‘j’, 1] --> C = [1, ‘a’]

A = [1, 'a', 4, 90]
B = ['a', 8, 'j', 1]
C = []
for i in A:
    if i in B:
        C.append(i)
print(C)

9.有一个数字列表，获取这个列表中的最大值.(注意: 不能使用max函数)

例如: nums = [19, 89, 90, 600, 1] —> 600

nums = [19, 89, 90, 600, 1]
max_value = nums[0]
for item in nums[1:]:
    if item > max_value:
        max_value = item
print(max_value)

10.获取列表中出现次数最多的元素

例如：nums = [1, 2, 3,1,4,2,1,3,7,3,3] —> 打印:3

# nums = [1, 2, 3, 1, 4, 2, 1, 3, 7, 3, 3, 1] —> 打印:3
nums = [1, 2, 3, 1, 4, 2, 1, 3, 7, 3, 3, 1]

# 方法一:
# 去重
new_nums = []
for item in nums:
    if item not in new_nums:
        new_nums.append(item)

max_count = 0
for item in new_nums:
    i_count = nums.count(item)
    if i_count > max_count:
        max_count = i_count

for item in new_nums:
    if nums.count(item) == max_count:
        print(item)