python+AI第三课

列表

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

>>>[1, 2, 3]
[1, 2, 3]
>>>['zhangsan', 2, 3.45]
['zhangsan', 2, 3.45]
>>>[[2, 3, 5], [5, 8, 9], [9, 8, 10]]
[[2, 3, 5], [5, 8, 9], [9, 8, 10]]

创建列表

list1 = ['鲁班', '安琪拉', '狄仁杰', ['詹姆斯', '乔丹', '科比']]
#查看列表内的元素个数
print(len(list1))
#4

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

list1.append(['1', '2', '3'])
print(list1)
#['鲁班', '安琪拉', '狄仁杰', ['詹姆斯', '乔丹', '科比'], ['1', '2', '3']]

使用inser向列表任意位置插入元素，不改变起内存首地址，属于原地操作

list1.insert(3, '今天天气不错')
print(list1)
#['鲁班', '安琪拉', '狄仁杰', '今天天气不错', ['詹姆斯', '乔丹', '科比'], ['1', '2', '3']]

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

list1.extend([3, 4, 5])
print(list1)
print(len(list1))
#['鲁班', '安琪拉', '狄仁杰', '今天天气不错', ['詹姆斯', '乔丹', '科比'], ['1', '2', '3'], 3, 4, 5]
# 9

列表的访问
列表名[index]

print(list1[4])
#['詹姆斯', '乔丹', '科比']
print(list1[4][1])
#乔丹

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

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方法删除并返回指定（默认是最后一个）位置元素，如果超出给定list的索引范围，会抛出异常

z = x.pop()
print(x)
#[1, 2]
print(z)
#3

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

x = [1, 2, 3, 3, 5]
x.remove(3)
print(x)
#[1, 2, 3, 5]

使用clear方法清空列表

x.clear()
print(x)
#[]

使用del删除列表中的指定位置的元素，如果超出列表范围，则抛出异常

del x[2]
print(x)
[1, 2, 5]

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

x = [1, 2, 2, 2, 3, '4']
print(x.count(2))
#3
print(x.count(0))
#0

列表的查找
index获取制定元素搜词出现的下标，若列表中不存在指定的元素，抛出异常

print(x.index(2))
#1
print(x.index(2, 2, 4))
#2

in 和 not in 测试列表是否含有该元素返回布尔值

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

列表的排序
列表的内置排序方法：列表名.sort()

list1 = [x for x in range(0, 15)]
print(list1)
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
list2 = []
for x in range(15):
    list2.insert(0, x)
print(list2)
#[14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
#打乱顺序
from random import shuffle
shuffle(list2)
print(f'打乱顺序后{list2}')
#打乱顺序后[11, 9, 2, 13, 14, 0, 10, 6, 5, 12, 7, 3, 1, 8, 4]
list2.sort()
print(f'排序后{list2}')
#排序后[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
list2.sort(reverse = True)
print(list2)
#[14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

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

list2.reverse()
print(list2)

sorted()对列表进排序并返回新的列表，不对原来列表进行修改

l = sorted(list2)
print(l)
# 打乱顺序后[5, 3, 2, 11, 6, 1, 0, 9, 10, 13, 4, 8, 7, 12, 14]
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

reversed()返回一个逆序排列后的迭代对象，不对原列表做任何修改。

ll = reversed(list2)
print(ll)
#<list_reverseiterator object at 0x004CEDB0>
ll = list(reversed(list2))
print(ll)
#[2, 10, 11, 6, 13, 0, 9, 14, 7, 12, 5, 4, 3, 1, 8]

用于序列（列表，元组，字符串）操作常用函数
1.len
返回序列中元素的个数，适用对象（元组，列表，字典，集合）

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

2.max和min
返回序列中最大或者最小元素适用对象（元组，列表，字典，集合）

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

3.sum
对迭代对象求和运算适用对象（元组，列表，字典，集合）

print(sum(x))
#6

4.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(list(zipped))
#[(1, 4), (2, 5), (3, 6)]
zipped1 = zip(a, c)
print(list(zipped1))
#[(1, 4), (2, 5), (3, 6)]
#元素个数与最短的一致

5.zip(星)
可以理解为解压缩，返回二维矩阵

zip(*zip(a,b))
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]

6.enumerate
枚举列表元素，返回美剧对象，其中每个元素为包含下标和值的元组

for x in enumerate(['a', 'b', 'c']):
    print(x)
# (0, 'a')
# (1, 'b')
# (2, 'c')

遍历列表的三种方式

#1
a = ['a','b','c','d','e','f']
for i in a:
    print(i)
#2
for i in range(len(a)):
    print(i,a[i])
#3
for i,ele in enumerate(a):
    print(i,ele)

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

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

逻辑上是一个for循环，只不过更加简洁。

li = [i for i  in range(0, 10)]
print(li)
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

列表嵌套

l2 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
#平铺整个列表
res = []
for l in l2:
    for x in l:
        res.append(x)
print(res)
#[1, 2, 3, 4, 5, 6, 7, 8, 9]
#使用列表推导式实现嵌套列表的平铺
print([x for l in l2 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)
#[-4, 0, -10, -3, 2, 4, 8, 7, 10, -4]

使用列表推导式，筛选出所有大于零的元素

pick = [ i for i in L2 if i >0]
print(pick)
# [-9, 1, 4, -4, 4, 9, 5, 10, -5, -6]
# [1, 4, 4, 9, 5, 10]

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

num = 13
year = 0
while 1:
    if num>=26:
        break
    num=num*(1+0.008)
    year += 1
print(f"经过{year}年，人口达到26亿")

2.求1！+2！+3！+4！+5！的和。
方法1

import math
s = sum([math.factorial(i) for i in range(1, 6)])
print(s)

方法2

sum=1
count=0
for i in range(1,6):
    sum *= i
    count += sum
print(count)

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

  *
* * *

方法1

N = int(input('输入一个奇数N:'))
line = int(N / 2) + 1
m = 1
for i in range(line):
  print((' ' * ((N - m) // 2)) + ('*' * m) + (' ' * ((N - m) // 2)))
  m += 2

方法2

N = int(input('输入一个奇数N:'))
i = 0
while i <= N:
    space = ' ' * ((N - i) // 2)
    n = '*' * (i + 1)
    print(f'{space}{n}{space}')
    i += 2

方法3

N = int(input('输入一个奇数N:'))
for i in range(0, N + 1):
     for j in range(0, N - i):
         print(end=' ')
     for k in range(N - i, N):
         print('*',end=' ')
     print('')

作业：
分页实现内容
a.通过for循环创建301条数据,数据类型不限,如:

zhangsan-1     zhangsan1@neuedu.com      pwd1
zhangsan-2     zhangsan2@neuedu.com      pwd2
zhangsan-3     zhangsan3@neuedu.com      pwd3

提示用户请输入要查看的页码，当用户输出指定页码，也显示指定数据
注意:
每页显示10条数据

while True:
    j = int(input('请输入要查看的页码:'))
    #所有数据
    list = []
    for i in range(1, 301):
        list.append(f'zhangsan-{i}, zhangsan{i}@neuedu.com, pwd{i}')
    if j == 1:
        print('您正在访问第1页')
        for x in list[0:10]:
            print([x])
        break
    elif j > 30:
        print('没有该页码，请重新输入')
    else:
        print(f'您正在访问第{j}页')
        for x in list[j*10-10 : j*10]:
            print([x])
        break