【漫漫转码路】Python Day 04

一、列表对象方法

1、list.append(x)

list.append(x):在列表末尾添加一个数据，修改原数据，无返回值；

# 例如
list1 = [0, 1, 2, 3, 4]
list1.append(5)
list2 = [0, 1, 2, 3, 4]
list2[len(list2):] = [5]  # 等同于append
print(list1)
print(list2)

# 终端输出
[0, 1, 2, 3, 4, 5]
[0, 1, 2, 3, 4, 5]

2、list.extend(iterable)

list.extend(iterable):使用可迭代对象iterable中所有元素来扩展list，修改原数据，无返回值；

# 例如
list1 = [0, 1, 2, 3, 4]
str1 = 'abcde'
li1 = [0,2,4]
tuple1 = (1,3,5)
dic1 = {'f' :1, 'g' :2, 'h' :3}
list1.extend(str1)
print(list1)
list1.extend(li1)
print(list1)
list1.extend(tuple1)
print(list1)
list1.extend(dic1)
print(list1)

# 终端输出
[0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e']
[0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e', 0, 2, 4]
[0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e', 0, 2, 4, 1, 3, 5]
[0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e', 0, 2, 4, 1, 3, 5, 'f', 'g', 'h']

3、list.insert(i,x)

list.insert(i,x):在list中给定位置i中插入一个x，修改原数据，无返回值；

# 例如
list1 = [0, 1, 2, 3, 4]
list1.insert(2,5)
print(list1)

# 终端输出
[0, 1, 5, 2, 3, 4]

4、list.sort([key],reverse = False)

list.sort([key],reverse = False):将list中元素经过函数key应用之后排序，默认为升序，reverse = True是降序，key需要上传关键字参数，修改原数据，无返回值；

# 例如
list1 = [0,5,-8,1]
list1.sort(key = abs)
print(list1)
list2 = [8,-1,0,-3]
list2.sort(reverse= True)
print(list2)

# 终端输出
[0, 1, 5, -8]  # 将每个元素经过abs(绝对值)后排序
[8, 0, -1, -3]  # reverse = True表示降序

函数sorted(iterable[,key],reverse = False):将可迭代对象iterable中的元素经过函数key的应用之后排序，默认升序，reverse = True为降序；

5、list.reverse()

list.reverse():将list中元素反向，返回值为空；

# 例如
list1 = [5, 8, 6, 9, 7, 4]
list2 = [5, 8, 6, 9, 7, 4]
list1.reverse()
list3 = list2[::-1]  # 与reverse效果一致
print(list1)
print(list3)

# 终端输出
[4, 7, 9, 6, 8, 5]
[4, 7, 9, 6, 8, 5]

函数reversed(seq):对序列seq(序列:字符串、列表或元组)返回一个反向迭代器

# 例如
list1 = [5, 8, 7, 9, 565, 4, 8]
obj = reversed(list1)
print(list(obj))
print(list(obj))

# 终端输出
[8, 4, 565, 9, 7, 8, 5]
[]  # 迭代器仅能使用一次

注意： reversed返回为一个地址需要一个可迭代对象来接收；

6、list.count(x)

list.count(x):返回x在列表中出现的次数；

# 例如
list1 = [1, 5, 8, 9, 5, 4, 1, 1, 0]
print(list1.count(1))

# 终端输出
3

7、list.index(x[,start[,end]])

list.index(x[,start[,end]]):从左向右查找x在list中第一次出现的次数，若找不到，则报错；

# 例如
list1 = [1, 5, 8, 9, 5, 4, 1, 1, 0]
print(list1.index(5))
print(list1.index(5, 3))

# 终端输出
1
4

8、list.pop([i])

list.pop([i]):删除list中索引为i的数据，并返回该数据；

# 例如
list1 = [5, 8, 7, 9, 565, 4, 8]
list1.pop(2)
print(list1)
list1.pop()
print(list1)

# 终端输出
[5, 8, 9, 565, 4, 8]
[5, 8, 9, 565, 4]  # 当不传i时，则默认删除最后一个数据

9、list.remove(x)

list.remove(x):移除列表中第一个x，修改原数据，无返回值；

# 例如
list1 = [1, 5, 8, 9, 5, 4, 1, 1, 0]
list1.remove(5)
print(list1)

# 终端输出
[1, 8, 9, 5, 4, 1, 1, 0]

注意： 如果list中无此数据，则报错；

10、list.copy()

list.copy():对list进行拷贝，并输出新的列表

# 例如
list1 = [1, 5, 8, 9, 5, 4, 1, 1, 0]
list2 = list1.copy()
print(list1)
print(list2)

# 终端输出
[1, 5, 8, 9, 5, 4, 1, 1, 0]
[1, 5, 8, 9, 5, 4, 1, 1, 0]

11、list.clear()

list.clear():移除列表中所有元素，修改原数据，无返回值；

# 例如
list1 = [1, 5, 8, 9, 5, 4, 1, 1, 0]
list2 = [1, 5, 8, 9, 5, 4, 1, 1, 0]
list1.clear()
del list2[:]  # 作用等同于clear
print(list1)
print(list2)

# 终端输出
[]
[]

注意：del语句为解除引用，并不是直接的删除；

二、元组及其对象方法

1、元组

元组(Tuple)是序列，但是不可变；
在()中添加元素，并使用逗号隔开（不加括号也认为是元组）
当元组中只有一个元素时，可以表达为：

# 例如
tup1 = (1,)
tup2 = 1,
print(type(tup1))
print(type(tup2))

# 终端输出
<class 'tuple'>
<class 'tuple'>

注意： 元组不可变，但是元组中的列表可变

# 例如
tup1 = (2, 5, 8, 9, [3, 5], 'abc')
tup1[4][1] = 7
print(tup1)

# 终端输出
2, 5, 8, 9, [3, 7], 'abc')

tuple(iterable):`

# 例如
print(tuple()) # 返回空元组 ()
print(tuple("China")) # ('C', 'h', 'i', 'n', 'a')
print(tuple([1, 2, 3])) # (1, 2, 3)
print(tuple({1: 2, 3: 4})) # (1, 3)
print(tuple({1, 2, 3, 4})) # (1, 2, 3, 4)

# 终端输出
()
('C', 'h', 'i', 'n', 'a')
(1, 2, 3)
(1, 3)
(1, 2, 3, 4)

2、元组对象方法

(1)tuple.count(x)

tuple.count(x):查找x在tuple中出现的次数；

# 例如
tup1 = (2, 5, 8, 5, 9, [3, 5], 'abc')
print(tup1.count(5))

# 终端输出
2

(2)tuple.index(x[,start[,end]])

tuple.index(x[,start[,end]]):返回x在tuple中第一次出现的索引；

# 例如
tup1 = (2, 5, 8, 5, 9, [3, 5], 'abc')
print(tup1.index(5))

# 终端输出
1

三、字典及6种创建形式

1、字典(Dictionary)

字典可变，不是序列；
字典由键值对组成，键必须是不可变的，与元组不同，键的不可变表示其中包含的所有数据不可变，值无限制；
键不能重复，值可以重复；
当字典作为可迭代对象时，只有键参与；
字典在{}中添加键值对，用逗号隔开；

2、创建字典的6种方式

(1)直接用{}创建

# 例如
dic1 = {'姓名': 'lisa', '年龄': 16}
print(dic1)

# 终端输出
{'姓名': 'lisa', '年龄': 16}

(2)空字典中添加键值对

# 例如
dict1 = {}
dict1['姓名'] = 'lisa'
dict1['年龄'] = 16
print(dict1)

# 终端输出
{'姓名': 'lisa', '年龄': 16}

(3)把键作为关键字传入

# 例如
dict1 = dict(姓名 = 'lisa', 年龄 = 16)
print(dict1)

# 终端输出
{'姓名': 'lisa', '年龄': 16}

(4)用可迭代对象构造字典

元组、列表、集合均可

# 例如
dict1 = dict([('姓名','lisa'),('年龄',16)])
print(dict1)

# 终端输出
{'姓名': 'lisa', '年龄': 16}

(5)用zip()把对应元素打包成元组，类似于(4)

# 例如
dict1 = dict(zip(['姓名', 'lisa'], ['年龄', 16]))
print(dict1)

# 终端输出
{'姓名': '年龄', 'lisa': 16}

(6)利用类方法fromkeys()创建

# 例如
dic1 = dict.fromkeys(("姓名", "年龄", "性别"))
print(dic1)
dic2 = dict.fromkeys(("姓名", "年龄", "性别"), "I don't know!")
print(dic2)

# 终端输出
{'姓名': None, '年龄': None, '性别': None}  # 拉链无配对则键值对的值为空
{'姓名': "I don't know!", '年龄': "I don't know!", '性别': "I don't know!"}  # 该方法创建的字典所有键只能对应相同值

3、一些函数

(1)dict(**kwarg) / dict(iterable) / dict(mapping)

创建一个字典并返回，分别对应字典6种创建方法中的方法(3)、(4)、(5）
其中：dict(**kwarg)中两个星号表示不定长参数且只能上传关键字参数，
一个星号表示不定长参数无限制；

(2)zip(*iterables)

返回一个迭代器，其中第一个元素来自迭代器中每个可迭代对象的第一个元素，以此类推，第i个元素来自迭代器中每个可迭代对象的第i个元素；
如果可迭代对象元素数量不一，则以最短的为停止点
不传参数时则返回一个空值
只有一个可迭代对象时，则生成的元组只有一个元素

# 例如
obj = zip(["one", "two", "three"], [1, 2, 3])
obj1 = zip(["one", "two", "three"], [1, 2, 3, 4])
obj2 = zip(["one", "two", "three"])
obj3 = zip()
print(tuple(obj))
print(tuple(obj1))
print(tuple(obj2))
print(tuple(obj3))

# 终端输出
(('one', 1), ('two', 2), ('three', 3))
(('one', 1), ('two', 2), ('three', 3))
(('one',), ('two',), ('three',))
()