Python 列表和元组

# coding=utf-8


###################################################################
# 1、序列
# 最常用的两种序列是列表、元组、字符串，列表可以修改，元组不可以修改
# Python 序列中的所有元素都有编号 从0开始递增
# 序列常用的操作 索引 切片 相加 相乘 成员资格检查
edward = ['Edward Gumby', 42]
john = ['John Smith', 50]
database = [edward, john]
print(database)

###################################################################
# 1.1.索引
# 序列中的元素可以通过索引来获取，当索引为负数时，Python 将从右往左数，
# 因此索引为-1的元素是序列中最后一个元素

greeting = "Hello World!"
print(greeting[1])
print(greeting[-1])
print(greeting[0])

# 对于字符串字面量以及其他的序列字面量，可直接对其执行索引操作，无需先将其赋值给变量
print("Hello World"[-1])
print("Hello World"[1])

# 如果函数调用返回一个序列，可直接对其执行索引操作。
# 例如想获取用户输入的年份的第4位
# fourth = input('year:')[3]
# print(fourth)

# 代码示例
# 输入年 月（1~12） 日（数1~31），再使用相应的月份名将日期打印出来
# 月份列表
months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August',
          'September', 'October', 'November', 'December']
# 一个列表 其中包含数1~31 对应的结尾
endings = ['st', 'nd', 'rd'] + 17 * ['th'] \
          + ['st', 'nd', 'rd'] + 7 * ['th'] \
          + ['st']

# year = input('Year:')
# month = input('Month:')
# day = input('Day:')
#
# month_number = int(month)
# day_number =int(day)
#
# month_name = months[month_number-1]
# ordinal = day + endings[day_number-1]
#
# print(month_name + ' ' +ordinal + '，' + year)


###################################################################
# 1.2.切片
# 可以通过切片来访问特定范围内的元素.用两个索引中间用冒号隔开 [索引1:索引2]
# 索引1是切片包含的第一个元素的编号，索引2是切片后余下的第一个元素的编号
# 切片包含索引1对应的元素 但不包含索引2对应的元素
tag = ''
print(tag[9:23])
print(tag[9:-5])

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(numbers[0:3])
print(numbers[3:-1])

# 1.2.1 简写
# 切片的索引1如果位于索引2的后面就会返回一个空序列
print(numbers[-3:0])
# 如果切片结束于序列末尾（包含最后一个元素），可省略第二索引[索引1:]
print(numbers[7:])
# 如果切片开始于序列开头（包含第一个元素），可省略第一个索引[:索引2]
print(numbers[:3])
# 如果复制整个序列，可将两个索引都省略
print(numbers[:])

# 代码示例
# 提示用户输入一个网址URL 并从中提取出域名
# 从类似于http://www.something.com URL中提取域名
# url = input('Please enter the URL:')
# domain = url[11:-4]
# print("Domain name:" + domain)

# 1.2.2 步长
# 在执行切片操作时，[索引1:索引2]只指定了起点和终点，省略了另一个参数，即步长。
# 步长为1，表示一个从一个元素移到下一个元素。因此切片[索引1：索引2]包含了序列中的所有元素
# 步长为2，将会从起点到终点，每隔1个元素提取元素
print(numbers[0:10:1])
print(numbers[0:10:2])
# 从序列中每隔3个元素提取1个元素
print(numbers[::4])
# 步长不可以为0，为0将无法向前移动
# 步长为正数时，切片是从起点到终点提取元素的，负数时，从终点到起点提取元素
# 步长为负数时，索引1一定比索引2大 从右往左数 不包含索引2
print(numbers[::-4])

# [6::-2]  包含索引1 不包含索引2
# 步长为负数 索引1要比索引2大 相当于从索引为6数到索引为序列第一位处，
# 由于是省略了索引2，故包含索引为0的元素，
# 再以步长为2提取元素
print(numbers[6::-2])

# [6:0:-2]  包含索引1 不包含索引2
# 步长为负数 索引1要比索引2大 相当于从索引为6数到索引为索引为0处，
# 由于是不包含索引2，故不包含索引为0的元素，
# 再以步长为2提取元素
print(numbers[6:0:-2])

# [:6:-2] 包含索引1 不包含索引2
# 步长为负数 索引1要比索引2大 相当于从最后一位数到索引为6处，
# 由于是省略了索引1，故包含索引为9的元素，
# 再以步长为2提取元素
print(numbers[:6:-2])

# [:6:-2] 包含索引1 不包含索引2
# 步长为负数 索引1要比索引2大 相当于从最后一位数到索引为6处，
# 由于包含索引1，故包含索引为9的元素，
# 再以步长为2提取元素
print(numbers[9:6:-2])

# [-2:6:-2] 包含索引1 不包含索引2 索引-2 等价于 索引为8
# [-2:6:-2] 等价于 [8:6:-2]
print(numbers[-2:6:-2])
print(numbers[8:6:-2])

# [:-5:-2] 等价于[:5:-2]
print(numbers[:-5:-2])

###################################################################
# 2.3 序列相加
xulie1 = [1, 2, 3] + [4, 5, 6]
print(xulie1)

xulie2 = [1, 2, 3] + [3, 2, 1]
print(xulie2)

print('Hello' + 'World' + '!')

# 不能拼接不同类型的序列 比如列表+字符串
# print('Hello' + [1,2,3]) 这个会报错


###################################################################
# 1.2.4 序列相乘
# 将序列与整数数x相乘时，将重复这个序列x次 创建一个新序列
xulie3 = 'Python' * 5
print(xulie3)

xulie4 = ['42'] * 5
print(xulie4)

# 空序列 []
# 在Python中 None表示什么都没有
# 初始化一个长度为10的空序列 可以用[None] *10
seq = [None] * 10
print(seq)

# 代码示例
# 打印一个方框，且在方框的中心位置打印一个句子
sentence = "Hello World!"
screen_width = 80
text_width = len(sentence)
box_width = text_width + 6
left_margin = (screen_width - box_width) // 2

print(' ' * left_margin + '+' + '-' * (box_width - 2) + '+')
print(' ' * left_margin + '|  ' + ' ' * text_width + '  |')
print(' ' * left_margin + '|  ' + sentence + '  |')
print(' ' * left_margin + '|  ' + ' ' * text_width + '  |')
print(' ' * left_margin + '+' + '-' * (box_width - 2) + '+')

###################################################################
# 1.2.5 成员资格检查 in
# 运算符in 成功返回True 失败返回False
permissions = 'rw'
print('w' in permissions)
print('x' in permissions)

users = ['Tom', 'foo', 'bar']
print('foo' in users)
print('tom' in users)

# 代码示例
# 从用户那获取一个用户名和一个PIN码，并检查它们组成的列表是否包含在数据库中
database = [
    ['albert', '1234'],
    ['dilbert', '4242'],
    ['smith', '7534'],
    ['jones', '9843']
]

username = 'albert'
pin = '1234'
if [username, pin] in database: print('Access granted')

# 1.2.6 长度len  最大值max 最小值min
numbers = [100, 34, 999]
print()
print(max(numbers))
print(min(numbers))
print(len(numbers))

print()
print(min(18, 20, 16))
print(max([18, 20, 16]))

###################################################################
# 2、列表
# 2.1 函数list
# 可以通过函数list 将字符串转换成列表
seq1 = list('Hello')
print()
print(seq1)
# ''.join(somelist) 可以将字符列表转换成字符串
str1 = ''.join(seq1)
print(str1)

###################################################################

# 2.2 基本的列表操作

# 2.2.1 修改列表：给元素赋值
# 通过索引给特定位置的元素赋值，如x[1] =2
# 注意 不可以给不存在的元素赋值
x = [1, 1, 1, 1]
x[1] = 2
print(x)

# 2.2.2 删除元素
x = [1, 2, 3, 4]
del x[1]
print(x)

x = ['Alice', 'Beth', 'Cecil', 'Dee-Dee']
del x[1:3]
print(x)

# 2.2.3 给切片赋值
print()
name = list('Perl')
print(name)
name[2:] = list('ar')
print(name)
print()

# 通过切片赋值，可将切片替换为长度与其不同的序列
name = list('Perl')
name[1:] = list('ython')
print(name)

# 通过切片赋值，可在不替换原有元素的情况下插入元素 [插入位置索引:插入位置索引]
numbers = [1, 5]
numbers[1:1] = [2, 3, 4]
print(numbers)

# 通过切片赋值，可以删除某一个切片 [索引1:索引2] =[]
print()
numbers = [1, 2, 3, 4, 5]
numbers[1:4] = []
print(numbers)
print()

# 步长不为1的切片赋值 赋值的序列要和切片的长度一样 且不能赋值为空
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers[1:5:2] = [3] * len(numbers[1:5:2])
print(numbers)
print()

# 步长不为1的切片 可以通过del的方式赋空
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
del numbers[1:5:2]
print(numbers)
print()

# 2.3 列表方法

# 2.3.1 append 直接修改旧列表 不会返回新列表 无返回值
# 方法 append用于将一个对象附加到末尾
# 变量不能命名为list，list是一个函数，如果有一个变量命名为list，就会导致list不能调用
lst = [1, 2, 3]
lst.append(4)
print(lst)
print()

# 2.3.2 clear 清空列表的内容 无返回值
lst = [1, 2, 3]
lst.clear()
print(lst)
print()

# 2.3.3 copy 复制列表 有返回值
# 常规的复制只是将一个名称关联到列表
a = [1, 2, 3]
b = a
b[1] = 4
print(a)
print()

# 如果想让a 和 b指向不同的列表，就必须b关联到a的副本
# 类似于a[:] 或 list(a)
a = [1, 2, 3]
b = a.copy()
b[1] = 4
print(a)
print()

# a[:] 复制
a = [1, 2, 3]
b = a[:]
b[1] = 4
print(a)
print()

# list() 复制
a = [1, 2, 3]
b = list(a)
b[1] = 4
print(a)
print()

# 2.3.4 count 有返回值
# 计算指定元素在列表中出现的次数
a = [1, 2, [1, 2], 3, 3, [1, 2], 3]
print(a.count(3))
print(a.count([1, 2]))
print()

# 2.3.5 extend 无返回值
# extend 能够同时将多个值附加到列表末尾，为此可将这些值组成的序列作为一个参数提供给方法extend
a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
print(a)
print()

# 对比append
a = [1, 2, 3]
b = [4, 5, 6]
a.append(b)
print(a)
print()

# 对比拼接+
# extend 会修改原序列再返回一个新序列 而拼接不会修改原序列
# 常规拼接 必须使用a和b的副本来创建一个列表，因此在实现a=a+b的效果时，效率会比extend低
a = [1, 2, 3]
b = [4, 5, 6]
a + b
print(a)
print(b)
print(a + b)
print()

# 2.3.6 index 有返回值
# 方法index 在列表中查找指定值第一次出现的索引
# 搜索不存在的指定值时 会报异常
knights = ['We', 'Are', 'The', 'knights', 'who', 'say', 'in']
print(knights.index('who'))

# print(knights.index('THT')) 会报异常

# 2.3.7 insert 无返回值
# 方法insert用于将一个对象插入列表
numbers = [1, 2, 3, 5, 6, 7]
numbers.insert(3, 'four')
print(numbers)
print()

# 2.3.8 pop 有返回值
# 方法pop从列表中删除一个元素(末尾为最后一个元素),并返回这一元素
# 方法pop是唯一既修改列表又返回一个非None的列表方法
x = [1, 2, 3]
y = x.pop()
print(x)
print(y)

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

# 2.3.9 remove 无返回值
# 方法remove用于删除 第一个 为指定值的元素
a = [1, 2, 3, 2, 3]
a.remove(2)
print(a)
print()

# 2.3.10 reverse 无返回值
# 方法 reverse 按相反的顺序排列列表中的元素
a = [1, 2, 3]
a.reverse()
print(a)
print()

# 2.3.11 sort 无返回值
# sort 对列表就地排序 会修改原序列
a = [2, 4, 1, 3, 7, 9, 5]
a.sort()
print(a)
print()

# sorted 有返回值
a = [2, 4, 1, 3, 7, 9, 5]
b = sorted(a)
print(b)
print()

# 2.3.12 高级排序
# 方法sort可以接受两个参数 key 和 reverse
# key 类似于一个排序函数 在排序过程中，不是直接使用这个函数来判断一个元素是否比另个元素小
# 而是为每一个元素创建一个键，根据键来排序
# 比如需要根据元素长度排序时，可以将key设置为len，

# key=len
x = ['Tom', 'Smith', 'Tyon', 'Python', 'A', 'BC']
x.sort(key=len)
print(x)

# reverse = True
x = [1, 3, 6, 4, 5, 7]
x.sort(reverse=True)
print(x)

# 2.4 元组
# 元组不可修改 列表可以修改
# 元组用()
(1, 2, 3)
# 空元组
()
# 如果元组只有一个值(2,) 逗号至关重要
(2,)

x = 3 * (40 + 2)
print(x)

x = 3 * (40 + 2,)
print(x)
print()

# tuple 将序列转换成元组
x = 3 * [42]
y = tuple(x)
print(x)
print(y)
print()

# 元组的创建及其访问方式 和 其他序列相同
# 元组的切片也是元组 列表的切片也是列表
x = 1, 2, 3
print(x)
print(x[1])
print(x[0:2])