template = 'Life{i} short,{y} need{p}.'

result=template.format(i='is',y='you',p='Python')

print(result)

单个元素的tuple

定义tuple(元素)的‘()’,既可以表示tuple，又可以作为括号表示运算时的优先级,所以在定义一个元素的tuple时，要在单个元素的后边追加‘,’。

示例：
T = (1, )
print(T) # ==> (1, )

访问tuple(元组)元素的其他方法

1.count()方法：用于统计tuple中某个元素出现的次数，不存在的元素，count()方法不会报错，会返回0

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
print(T.count(1)) # ==> 3
print(T.count(5)) # ==> 1

2.index()方法：返回指定元素的下标，当元组内有多个相同元素时，返回第一次出现的下标（注意：当指定的元素不存在时，index()方法会报错）

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
T.index(9) # ==> 10
T.index(5) # ==> 8
T.index(1) # ==> 0 # 多次出现，返回第一次出现的位置

print(r'''To be, or not to be: that is the question.nWhether it's nobler in the mind to suffer.''')

tuple（元组）

元组定义方式：使用小括号()将元组内的元素括起来。

例如：T = ('Alice', 'Bob', 'Candy', 'David', 'Ellena')

1.元组是有序的，可以包含0个或多个元素，支持索引访问、切片等操作。

    1.1索引访问

# 通过下标的方式访问元素
print(T[0]) # ==> Alice
print(T[4]) # ==> Ellena

     1.2切片操作

# 切片
print(T[1:3]) # ==> ('Bob', 'Candy')

2.元组数据类型可以把不是元组的容器转换为元组（例如：列表与元组互转）。

    2.1 列表转元组

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
print(L) # ==> ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
T = tuple(L)
print(T) # ==> ('Alice', 'Bob', 'Candy', 'David', 'Ellena')

    2.2元组转列表

T = ('Alice', 'Bob', 'Candy', 'David', 'Ellena')
print(T) # ==> ('Alice', 'Bob', 'Candy', 'David', 'Ellena')
L = list(T)
print(L) # ==> ['Alice', 'Bob', 'Candy', 'David', 'Ellena']

3.元组是固定不变的，元组中的每一个元素都不可被改变，不可以往元组中添加新数据。

注意：元组(tuple)的这个特性是非常重要的，在运行上tuple的性能是list的数倍。

替换list中的元素

通多索引的方式替换元素

1.通过正序索引

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
L[2] = 'Canlina'
print(L)

2.通过倒序索引

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
L[-3] = 'Canlina'
print(L)

注意：以上两种方式的索引不能越界

从list中删除元素

通过pop()方法删除元素，pop()可以传元素的位置来删除指定的元素，当pop()方法不传参数时，默认是删除最后一个元素

1.不传参：

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name = L.pop()
print(name) # ==> Ellena
print(L) # ==> L = ['Alice', 'Bob', 'Candy', 'David']

2.传参（要删除元素的索引）

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name = L.pop(2)
print(name) # ==> Candy
print(L) # ==> ['Alice', 'Bob', 'David', 'Ellena']

向list中添加新的元素

方式一：append()，将新元素追加到list的末尾

names = ['Alice', 'Bob', 'David', 'Ellena']
names.append('Candy')
print(names) # ==> ['Alice', 'Bob', 'David', 'Ellena', 'Candy']

方式二：insert()，将新元素添加到list中的任意位置，insert()方法需要两个参数，分别是需要插入的位置，以及需要插入的元素

names = ['Alice', 'Bob', 'David', 'Ellena']
names.insert(2, 'Candy')
print(names) # ==> ['Alice', 'Bob', 'Candy', 'David', 'Ellena']

list倒序访问

将索引设置为负数，来倒序访问

-1表示最后一个元素

-2标识倒数第二个元素

其他以此类推

注意：1.倒序访问也存在越界的问题，索引值不要大于list中的元素个数

         2.倒序访问时，索引是从-1开始

按索引访问list

通过索引获取list中的元素时，索引是从0开始，并且访问最后一个元素的索引是list中元素个数减一。

注意：索引不要超出范围。

切片获取子列表

names = ['Alice', 'Bob', 'David', 'Ellena']
sub_names = names[0:2]
print(sub_names)

注意：越界切片的话，不会出现Python运行错误，但是按照这样的下标去切片，获取不到任何元素。

names = ['Alice', 'Bob', 'David', 'Ellena']
sub_names = names[5:10]
print(sub_names) # ==> []

字符串也可以看作是一种特殊的列表，它只能按顺序存放多个字符

按顺序访问list

L = ['Alice', 66, 'Bob', True, 'False', 100]
for item in L:
    print(item)

容器

容器是一种数据结构，可以把多个元素放在一起，可以逐个迭代获取，可以通过in，not in等关键字判断是否包含。

在Python中，容器包括列表(list)、元组(tuple)、字典(dict)、集合(set)等。

list

list是有序的，放入的元素按一定书序排列

构造方法：把需要放入的元素，用[]括起来。

例如：scores = [45, 60, 75, 86, 49, 100]

list可以放入任意数据类型，不对放入的数据类型进行判断。

例如：L = ['Alice', 66, 'Bob', True, 'False', 100]

list中的内容打印

例如：
L = ['Alice', 66, 'Bob', True, 'False', 100]
print(L)

if-else语句

注意：1.else中，同样需要冒号；

         2.在else的子逻辑分支，同样需要缩进。

if语句

1.if语句最后加':'，表示判断语句结束，接下来是分支代码块

2.if判断的子分支代码，编写时需要缩进，在Python规范中，一般使用4个空格作为缩进

字符串截取

1.获取特定位置的字符，通过使用位置的方式获取。

    使用中括号'[]'访问。

s = 'ABC'
a = s[0] # 第一个
b = s[1] # 第二个
c = s[2] # 第三个
print(a) # ==> A
print(b) # ==> B
print(c) # ==> C

2.获取字符串的一部分，采用切片方式获取。

    在中括号[]中填入两个数字，中间用冒号分开，这是半闭半开区间，不包括最后的位置。

    第一个数表示子串开始位置；

    第二个数表示子串结束位置（不是代表截取的长度）。

ab = s[0:2] # 取字符串s中的第一个字符到第三个字符，不包括第三个字符
print(ab) # ==> AB