一、列表

列表是Python中内置有序可变序列，所有元素放在[]中，每个元素使用逗号隔开

• 创建列表

list1 = ['鲁班', '安琪拉', '狄仁杰', ['科比', '乔丹', '詹姆斯'], 111, 99.9]

• 列表的访问

格式：列表名[index]

list1 = ['鲁班', '安琪拉', '狄仁杰', ['科比', '乔丹', '詹姆斯'], 111, 99.9]
# 列表的访问
# 列表名[index]
print(list1[3])  # ['科比', '乔丹', '詹姆斯']
print(list1[3][1])  # 乔丹
# 查看列表里的元素个数
print(len(list1))  # 6

• 列表的添加操作

append()

向列表的尾部增加一个元素，不改变其内存首地址，属于原地操作

list1.append(['1', '2', '3'])
print('append添加后列表的值是', list1)  # append添加后离列表的值是 ['鲁班', '安琪拉', '狄仁杰', ['科比', '乔丹', '詹姆斯'], 111, 99.9, ['1', '2', '3']]

insert(index, object)

向列表任意位置插入一个元素，不改变其内存首地址，属于原地操作

list1.insert(3, '今天天气还不错')
print('insert添加后列表的值是', list1)  # insert 添加后列表的值是 ['鲁班', '安琪拉', '狄仁杰', '今天天气还不错', ['科比', '乔丹', '詹姆斯'], 111, 99.9, ['1', '2', '3']]

extend()

将另一个迭代对象的所有元素添加至该列表对象尾部，不改变其内存首地址，属于原地操作

list1.extend([3, 4, 5])
print('extend添加后列表的值是', list1)  # extend添加后列表的值是 ['鲁班', '安琪拉', '狄仁杰', '今天天气还不错', ['科比', '乔丹', '詹姆斯'], 111, 99.9, ['1', '2', '3'], 3, 4, 5]

• 列表的 + 和 * 操作

'+' 是连接两个列表
'*' 是复制列表
这两个操作并不是真的为列表添加元素，而是创建一个新的列表，不属于原地操作，返回的是新的列表

x = [1, 2, 3]
y = x + [4]
print(y)  # [1, 2, 3, 4]
y = x * 2
print(y)  # [1, 2, 3, 1, 2, 3]

• 列表元素的删除

pop()

使用列表的pop()方法删除并且返回指定（默认是最后一个）位置元素，如果给出的索引超过了list的范围则会抛出异常

x = [1, 2, 3, 4]
value = x.pop()
print(value)  # 4
print('删除后的x', x)  # 删除后的x [1, 2, 3]

remove()

删除首次出现的指定元素，如果列表中不存在要删除的元素，则抛出异常

x = [1, 2, 2, 3, 4]
x.remove(2)  
print('remove删除后', x)  # remove删除后 [1, 2, 3, 4]

clear()

x = [1, 2, 2, 3, 4]
x.clear()
print(x)  # []

del

删除列表中的指定位置的元素,如果列表超出索引范围，则抛出异常
del 列表[index]

x = [1, 2, 2, 2, 3, '4']
del x[5]
print(x)  # [1, 2, 2, 2, 3]

• 列表元素的计数

count()

统计指定元素在列表中出现的次数

# count 统计指定元素在列表中出现的次数
print(x.count(2))  # 3
print(x.count('4'))  # 1
print(x.count(0))  # 0

index()

获取指定元素首次出现的下标，若列表对象中不存在指定元素，抛异常

index() 获取指定元素首次出现的下标，若列表对象中不存在指定元素，抛异常
print(x.index(2))  # 1
print(x.index(4))  # 报错
print(x.index(2, 2, 4))  # 2

in

测试列表是否含有该元素 返回 bool类型

not in

测试列表是否含有该元素 返回 bool类型

print(4 in x)  # False
print(2 in x)  # True
print(4 not in x)  # True

• 列表的排序

列表的内置方法：列表名.sort（）

# 列表的内置方法：列表名.sort（）
list1 = []
for x in range(15):
    list1.insert(0, x)
print(list1)  # [14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
# 打乱顺序
from random import shuffle
shuffle(list1)
print('打乱顺序后', list1)  # 打乱顺序后 [12, 9, 13, 11, 14, 2, 4, 7, 3, 5, 6, 8, 0, 10, 1]
list1.sort()
print('排序后', list1)  # 排序后 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
list1.sort(reverse=True)  # 指定为逆序排序
print(list1)  # [14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

reverse()

将列表的所有元素原地逆序排序

# reverse()# 将列表的所有元素原地逆序排序
shuffle(list1)
print('打乱顺序后', list1)  # 打乱顺序后 [6, 3, 14, 8, 4, 12, 7, 13, 0, 1, 2, 9, 10, 11, 5]
list1.reverse()
print('排序后', list1)  # 排序后 [5, 11, 10, 9, 2, 1, 0, 13, 7, 12, 4, 8, 14, 3, 6]

sorted()

内置函数sorted 对列表进行排序并且返回新的列表，不对原来列表进行修改

# sorted()
# 内置函数sorted 对列表进行排序并且返回新的列表，不对原来列表进行修改
sorted(list1)
print('排序后', list1)  # 排序后 [13, 12, 0, 14, 11, 9, 10, 3, 6, 5, 8, 7, 1, 4, 2]
list1 = sorted(list1)
print('排序后', list1)  # 排序后 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

reversed()

返回一个逆序排序后的迭代对象，不对原来列表做修改

# reversed() 返回一个逆序排序后的迭代对象，不对原来列表做修改
list1 = reversed(list1)
print(list1)  # <list_reverseiterator object at 0x0043EDB0>
list1 = list(reversed(list1))
print(list1)  # [14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

• 用于序列（列表、原组、字符串）操作的常用内置函数

len()

返回序列中元素的个数 元组、列表、字典、集合

x = [1, 2, 3]
print(len(x))  # 3

max min

返回序列中中最大或最小的元素 同样适用于元组、列表、字典、集合

print(max(x))  # 3
print(min(x))  # 1

sum()

对迭代对象进行求和

print(sum(x))  # 6

zip()

返回可迭代的zip对象
常常用于同时迭代两个列表

# zip() 返回可迭代的zip对象
# 常常用于同时迭代两个列表
heros = ['鲁班', '后羿']
skills = ['无敌鲨鱼炮', '惩戒之箭']
for hero, skill in zip(heros, skills):
    print(hero, '------>', skill)
# 鲁班 ------> 无敌鲨鱼炮
# 后羿 ------> 惩戒之箭
a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]
zipped = zip(a, b)
print(zipped)  # <zip object at 0x00AA0878>
print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]
print(list(zip(a, c)))  # 元素个数与最短的一致 # [(1, 4), (2, 5), (3, 6)]

zip(*)

可以理解为解压，返回二维矩阵

# zip(*) 可以理解为解压，返回二维矩阵
print(list(zip(*zip(a, b))))  # [(1, 2, 3), (4, 5, 6)]
a1, a2 = zip(*zip(a, b))
print(list(a1))  # [1, 2, 3]
print(list(a2))  # [4, 5, 6]

enumerate

枚举L列表元素，返回枚举对象，其中每个元素包含索引和元素本身 的一个元组

enumerate # 枚举L列表元素，返回枚举对象，其中每个元素包含索引和元素本身 的一个元组
for x in enumerate('abcdef'):
    print(x)
"""
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')
(5, 'f')
"""
for x in enumerate(['a', 'b', 'c']):
    print(x)
"""
(0, 'a')
(1, 'b')
(2, 'c')
"""

• 遍历列表的三种方式

# 遍历列表的三种方式
# 1.
l1 = ['a', 'b', 'c', 'd', 'e']
for x in l1:
    print(x)
"""
a
b
c
d
e
"""
for i in range(len(l1)):
    print(l1[i])
"""
a
b
c
d
e
"""
for index, val in enumerate(l1):
    print(val)
"""
a
b
c
d
e
"""

• 列表推导式

列表推导式使用非常简洁的方式来快速生成满足特定需求的列表，代码具有非常强的可读性。
语法

[返回的表达式 for 临时变量 in 可迭代对象 条件表达式]

列表推导式 逻辑上是一个for循环， 只不过更加简洁

# -*- coding: utf-8 -*-
# @Time    : 2019/11/6 14:06
# @Author  : Han lei
# @Email   : hanlei5012@163.com
# @File    : demo12.py
# @Software: PyCharm
# 列表推导式
# 列表推导式使用非常简洁的方式来快速生成满足特定需求的列表，代码具有非常强的可读性。
# 语法
# [返回的表达式 for 临时变量 in 可迭代对象 条件表达式]
# 列表推导式 逻辑上是一个for循环， 只不过更加简洁
# li = [0, 1, ....9]
li = []
for i in range(10):
    li.append(i)
print(li)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print([i for i in range(10)])  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• 列表嵌套

示例：平铺列表

# 列表嵌套
L = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# 平铺这个列表
result = []
for l in L:
    for x in l:
        result.append(x)
print(result)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 使用列表推导式对列表进行平铺
print([str(x) for l in L for x in l])  # ['1', '2', '3', '4', '5', '6', '7', '8', '9']
# 过滤不符合条件的元素
from random import randint
# _ 下划线的目的是增强代码的可读性，告诉读代码的人这里不需要使用临时变量
l2 = [randint(-10, 10) for _ in range(10)]
print(l2)  # [9, 9, 9, 10, 8, -10, -1, -7, 0, 6]
# 使用列表推导式 筛选出所有大于0的元素
print([elem for elem in l2 if elem > 0])  # [9, 9, 9, 10, 8, 6]

二、课堂作业

(自己的代码)

1. 分页实现内容
   a.通过for循环创建301条数据,数据类型不限,如:
   zhangsan-1 zhangsan1@neuedu.com pwd1
   zhangsan-2 zhangsan2@neuedu.com pwd2
   zhangsan-3 zhangsan3@neuedu.com pwd3
   ...
   提示用户 请输入要查看的页码，当用户输出指定页码，也显示指定数据
   注意:
   每页显示10条数据

info_list = [['第{}章'.format(i), '{}个和尚挑水喝'.format(i)] for i in range(1, 302)]
print(len(info_list))
while True:
    page = int(input('请输入要查看的页码：'))
    if 1 <= page <= len(info_list)//10+1:
        for i in info_list[(page-1)*10: page*10]:
            print(i)
    else:
        print('请输入1~{}之间的页码'.format(len(info_list)//10+1))

2. 输入n的值，求出n的阶乘。

n = int(input('请输入n：'))
factorial = 1
for i in range(1, n+1):
    factorial *= i
print(factorial)

3. 折纸上月球
   大家都看过科幻片《火星救援The Martian》吧，电影里航天员们在太空中碰到各种情况都是靠计算机模拟、计算来解决问题的。
   我们在地球上也可以靠高大上的Python语言来解决问题。现在问题来了：我们都知道，月亮在一个椭圆形的轨道上绕地球公转，
   因此两者的距离是不断变化的，它们的最小距离是363300公里。现在我们都想去月球旅游（地球玩腻了，想换个口味），
   但是坐火箭上天一次就带辣么几个人，我们等不及。好消息，好消息，厂家现在开发出逆天神技——折纸上月球！
   只需一张很大的A4纸，厚度为0.088毫米，折一次就0.176毫米，折两次就0.352毫米……多折几次就很高了。
   穿上冲锋衣，拿上登山杖，带上自拍杆，我们爬着就可以上月球发朋友圈了。我就想问一句：要上月球，我们到底需要折多少次？

for n in range(1, 100000):
    if 0.088*2**n >= 363300000000:
        print(n)
        break  # 42

4. 篮球弹跳高度的计算
   书呆子就是书呆子，打个篮球脑子也不闲着。这种人说好听的叫‘geek’，说不好听的就是叫‘nerd’。
   这不，书呆子看着篮球在想：如果篮球从某一高度落下，每次落地后反弹回原来高度的一半再落下。
   那么球在第10次落地时，共经过多少米呢? 第10次反弹多高？ （你问我这个题是不是瞎编的？当然是了，你什么时候见过书呆子打篮球？）
   输入：输入一个整数h，单位是米，表示球的初始高度。
   输出：输出包含两行：
   第1行：到球第10次落地时，一共经过的距离。
   第2行：第10次弹跳的高度。
   例如输入：20 对应输出：第一行：59.921875 第二行：0.01953125

h_start = int(input('球的初始高度：'))
h_sum = 20
for i in range(1, 10):
    h_start = 0.5*h_start  # 每次起始高度
    h_sum = h_sum+h_start*2  # 第i次经过的距离（i>1)
    h_tan = 0.5*h_start  # 弹起的高度
print(h_sum, h_tan)

5. 我国现有13亿人口，设每年增长0.8%，编写程序，计算多少年后达到26亿？

people_rating = 0.008
people_sum = 13
for i in range(1, 100):
    people_sum *= (1+0.008)
    if people_sum >= 26:
        break
print(i)  # 87

6. 求1！+2！+3！+4！+5！的和

factorial_sum = 0
for i in range(1, 6):  # 获取需要阶乘的数字
    factorial = 1
    for x in range(1, i+1):
        factorial = factorial*x  # 求阶乘
    # print(sum)
    factorial_sum += factorial  # 求阶乘和
print(factorial_sum)

7. 星号三角形：
   读入一个整数N，N是奇数，输出由星号字符组成的等边三角形，
   要求：第1行1个星号，第2行3个星号，第3行5个星号，依次类推，最后一行共N的星号。

N = int(input('请输入一个整数：'))
[print((N-i)//2*' '+'*'*i) for i in range(N+1) if i % 2 == 1]