python基础（三）列表和元祖

1 列表
1.1 基本操作
可对列表执行所有的标准序列操作，如索引、切片、拼接和相乘，列表是可以修改的。

修改列表，给元素赋值

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

删除元素

name = ['bob', 'joj', 'zoz']
del name[1]
print(name) #['bob', 'zoz']

给切片赋值

#修改
name = list('hello')
name[3:] = list('xyz')
print(name)
#['h', 'e', 'l', 'x', 'y', 'z']

#插入
num1 = [1, 5]
num1[1:1] = [2, 3, 4]
print(num1)
#[1, 2, 3, 4, 5]

#删除
num2 = ['a', 'b', 'c', 'd', 'e']
num2[1:4] = []
print(num2)
#['a', 'e']
#del num2[1:4] 等效
#结合步长 del num2[1:4：2] => ['a', 'c', 'e']

1.2 列表方法
方法是与对象（列表，数，字符串等）紧密联系的函数，格式如object.method(arguments)

#append 用于将一个对象附加到列表末尾
lst = [1, 2, 3]
lst.append(4)
print(lst) #[1, 2, 3, 4]

#clean 清空列表
lst.clear()
print(lst) #[]  类似切片赋值lst[:] = []

#copy 复制列表，区别常规赋值，常规复制只是将另一个名称关联到列表
a = [1, 2, 3]
b = a
b[1] = 4
print(a) #[1, 4, 3]

a1 = [1, 2, 3]
b1 = a1.copy()
b1[1] = 4
print(a1) #[1, 2, 3]  a1，b1指向不同的列表

#count 计算指定的元素在列表中出现了多少次
print(['to', 'bo', 'ab', 'bo', 'bob'].count('bo')) #2
x = [[1, 2], 1, 1, [2, 1, [1, 2]]]
print(x.count(1))     #2
print(x.count([1,2])) #1

#extend 用一个列表来扩展另一个列表
a = [1, 2]
b = [3, 4]
a.extend(b)
print(a) #[1, 2, 3, 4]
#extend是直接修改原来的列表，拼接返回的是全新的队列，拼接可以a += b，就是将新队列的结果赋值给a，这样效率就没有extend高

#index 在队列中查找指定值第一次出现的索引
knights = ['We', 'are', 'the', 'who', 'say', 'ni']
print(knights.index('are')) #1
#print(knights.index('no')) #报错，值必须存在

#insert 将一个对象插入列表
c = [1, 2, 3, 5]
c.insert(3, 'four')  #c[3:3] = ['four']
print(c) #[1, 2, 3, 'four', 5]

#pop 从列表中删除一个元素（末尾为最后一个）并返回
d = [1, 2, 3]
print(d.pop())  #3
print(d)        #[1, 2]
print(d.pop(0)) #1
print(d)        #[2]

e = [1, 2, 3]
e.append(e.pop())
print(e) #[1, 2, 3]

#remove 删除第一个指定值得元素
f = ['to', 'be', 'or', 'not', 'to', 'be']
f.remove('be')
print(f) #['to', 'be', 'or', 'not', 'to', 'be']
#f.remove('bob') #报错，指定值必须存在

#reverse 按相反的顺序排列列表中的元素
h = [1, 2, 3]
h.reverse();
print(h) #[3, 2, 1]

#sort 就地对列表排序
h1 = ['za', 'ao', 'bob', 'boa']
h1.sort()
print(h1) #['ao', 'boa', 'bob', 'za']

h2 = h1.sort()
print(h2) #None  就地排序意味着对原来的列表进行修改，不返回任何值

高级排序
方法sort接受两个可选参数： key和reverse。这两个参数通常是按名称指定的，称为关键字参数，将在第6章详细讨论。参数key类似于参数cmp：你将其设置为一个用于排序的函数。然而，不会直接使用这个函数来判断一个元素是否比另一个元素小，而是使用它来为每个元素创建一个键，再根据这些键对元素进行排序。因此，要根据长度对元素进行排序，可将参数key设置为函数len。

x = ['aardvark', 'abalone', 'acme', 'add', 'aar']
x.sort(key = len)
print(x) #['add', 'aar', 'acme', 'abalone', 'aardvark']

对于另一个关键字参数reverse，只需将其指定为一个真值（ True或False）以指出是否要按相反的顺序对列表进行排序。

y = [4, 6, 2, 1, 7, 9]
y.sort(reverse = True)
print(y) #[9, 7, 6, 4, 2, 1]

2 元祖
与列表一样，元组也是序列，唯一的差别在于元组是不能修改的。元组语法很简单，只要将一些值用逗号分隔，就能自动创建一个元组。如果要创建的元组中只有一个元素，要在它的后面加上一个逗号‘，’。

temp1 = 1,2,3  #(1, 2, 3)
print(temp1) 
#(1, 2, 3)

temp2 = 3 * (4 + 2)
print(temp2) #18
temp3 = 3 * (4 + 2,)
print(temp3) #(6, 6, 6)

#tuple 进行类型转换
temp4 = tuple([1, 2, 3])
print(temp4)
#(1, 2, 3)
temp5 = tuple('abc')
print(temp5)
#('a', 'b', 'c')

元祖的访问和切片

x = 1, 2, 3
print(x[1])   #2
print(x[1:2]) #(2,) #元祖的切片还是元祖

元祖type

temp = ()
print(type(temp))
#<class 'tuple'>

temp1 = (1,)
print(type(temp1))
#<class 'tuple'>

temp2 = (1)
print(type(temp2))
#<class 'int'>

一个小demo

def get_info():
	name = "show"
	age = 10
	return name,age

name,age = get_info()
print(name)
print(age)
#show
#10

info = get_info()
print(info)
#('show', 10)

print(type(info))
#<class 'tuple'>

tuple 放弃了对元素的增删（内存结构设计上变的更精简），换取的是性能上的提升：创建 tuple 比 list 要快，存储空间比 list 占用更小。