python全栈区别_Python全栈之路-4-list与tuple

本文代码地址​github.com

Python中可以通过组合一些元素得到多种复合数据类型，其中最常用的是list，可以通过方括号，逗号分割一组元素得到. list可以包含不同类型的元素，但通常使用时各个元素类型相同，list是可变对象

通用序列运算

# 创建一个空列表

a = []

# 创建一个空列表

b = list()

c = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

d = ["Python", "CXX", "Go", "Java", "Javascript"]

# 通过range构造列表，注意range返回的是可迭代对象而不是列表

e = list(range(10))

print(c)

print(d)

print(e)

[1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

['Python', 'CXX', 'Go', 'Java', 'Javascript']

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 遍历列表元素

for item in d:

print(item)

print("-------分隔线-------")

# 通过enumerate遍历列表

for i, item in enumerate(d):

print("索引: {}，值: {}".format(i, item))

Python

CXX

Go

Java

Javascript

-------分隔线-------

索引: 0，值: Python

索引: 1，值: CXX

索引: 2，值: Go

索引: 3，值: Java

索引: 4，值: Javascript

# 判断值是否在列表中

print("Python" in d)

print("PHP" in d)

# 判断值是否不在列表中

print("CXX" not in d)

print("Scala" not in d)

True

False

False

True

# 列表拼接

f = c + e

print(f)

[1, 3, 5, 7, 9, 2, 4, 6, 8, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 自身重复若干次并拼接到一起

g = c * 3

print(g)

[1, 3, 5, 7, 9, 2, 4, 6, 8, 10, 1, 3, 5, 7, 9, 2, 4, 6, 8, 10, 1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

# 列表的下标访问

print(c)

# 第一个元素

print(c[0])

# 最后一个元素

print(c[-1])

# 起始下标为2，最后一个下标为6

print(c[2:7])

# 起始下标为3，省略终止下标表示一直访问到最末尾

print(c[3:])

# 省略起始下标表示下标从0开始

print(c[:7])

# 同时省略起始和终止下标表示起始下标为0，终止下标为末尾

print(c[:])

# 起始下标为2，最后一个下标为6，且步长为2

print(c[2:7:2])

# 起始下标为7，末尾下标为3，步长为负数表示从后往前访问

print(c[7:2:-1])

# 起始元素为倒数第3个元素，末尾元素为倒数第6个元素

print(c[-3:-7:-1])

# 逆序列表

print(c[::-1])

[1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

1

10

[5, 7, 9, 2, 4]

[7, 9, 2, 4, 6, 8, 10]

[1, 3, 5, 7, 9, 2, 4]

[1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

[5, 9, 4]

[6, 4, 2, 9, 7]

[6, 4, 2, 9]

[10, 8, 6, 4, 2, 9, 7, 5, 3, 1]

# 列表长度

print(len(c))

10

# 列表元素最大值

print(min(c))

# 列表元素最小值

print(max(c))

1

10

v = 3

# 值在列表中首次出现的索引

print(f.index(v))

# 值在列表中出现的次数

print(f.count(v))

1

2

可变序列运算

print(c)

# 列表是可变对象，可以直接修改列表元素

c[1] = 30

print(c)

# 修改一定范围内的元素

c[2:5] = [13, 15, 17]

print(c)

[1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

[1, 30, 5, 7, 9, 2, 4, 6, 8, 10]

[1, 30, 13, 15, 17, 2, 4, 6, 8, 10]

# 删除一个元素

del c[0]

print(c)

# 删除多个元素

del c[2:5]

print(c)

[30, 13, 15, 17, 2, 4, 6, 8, 10]

[30, 13, 4, 6, 8, 10]

# 在列表末尾追加元素

c.append(100)

print(c)

[30, 13, 4, 6, 8, 10, 100]

# 拷贝列表

h = c.copy()

print(h)

[30, 13, 4, 6, 8, 10, 100]

# 清空列表

h.clear()

print(h)

[]

# 追加一个列表到另一个列表

c.extend([10, 20, 30])

print(c)

[30, 13, 4, 6, 8, 10, 100, 10, 20, 30]

# 在给定索引处插入元素

c.insert(2, 99)

print(c)

[30, 13, 99, 4, 6, 8, 10, 100, 10, 20, 30]

# 删除并返回给定索引的元素

v = c.pop(2)

print(v)

print(c)

99

[30, 13, 4, 6, 8, 10, 100, 10, 20, 30]

# 删除给定值的元素

c.remove(6)

print(c)

[30, 13, 4, 8, 10, 100, 10, 20, 30]

# 列表逆序

c.reverse()

print(c)

[30, 20, 10, 100, 10, 8, 4, 13, 30]

# 对列表进行排序，默认升序排序

c.sort()

print(c)

[4, 8, 10, 10, 13, 20, 30, 30, 100]

# 降序排序

c.sort(reverse=True)

print(c)

[100, 30, 30, 20, 13, 10, 10, 8, 4]

# 排序的时候还可以自定义排序规则

# 元组中第一个元素表示姓名，第二个元素表示年龄

people = [("zhangsan", 18), ("lisi", 17), ("wangwu", 19)]

# 按年龄排序

people.sort(key=lambda x : x[1])

print(people)

# 按姓名排序

people.sort(key=lambda x : x[0])

print(people)

[('lisi', 17), ('zhangsan', 18), ('wangwu', 19)]

[('lisi', 17), ('wangwu', 19), ('zhangsan', 18)]

列表推导

列表推导可把某种操作应用于序列或可迭代对象的每个元素，然后使用操作结果来创建列表. 建议单层循环使用，多层循环不建议使用列表推导，可读性变差.

phones = ["huawei", "xiaomi", "oppo", "vivo", "oneplus", "meizu", "apple", "samsung"]

# 处理列表中所有元素

upper_phones = [phone.upper() for phone in phones]

print(upper_phones)

# 只处理列表中满足条件的元素

upper_phones = [phone.upper() for phone in phones if phone != "samsung"]

print(upper_phones)

['HUAWEI', 'XIAOMI', 'OPPO', 'VIVO', 'ONEPLUS', 'MEIZU', 'APPLE', 'SAMSUNG']

['HUAWEI', 'XIAOMI', 'OPPO', 'VIVO', 'ONEPLUS', 'MEIZU', 'APPLE']

元组

元组是由逗号隔开的元素组成，也可以用括号括起来. 元组是不可变对象

# 创建空元组

a = ()

# 创建空元组

b = tuple()

c = (1, 2, 3)

# 通过列表构造元组

d = tuple([1, 2, 3, 4, 5])

# 通过可迭代对象构造元组

e = tuple(range(10))

# 元组解包，以下代码表示将c中的值解包到x, _, y，其中_表示忽略该值

x, _, y = c

print(x)

print(y)

1

3

与列表一样，以下运算符同样适用于元组，其操作方式是一样的

列表与元组的区别与联系列表是可变对象，元组是不可变对象，对于列表可以原地修改列表元素，对于元组不能原地修改元组，只能获取修改的副本

列表和元组之间可以互相转换

zip

# zip函数可以聚合若干可迭代对象并返回一个可迭代对昂

name = ["张三", "李四", "王五", "赵六"]

age = [17, 19, 18, 21]

city = ["北京", "上海", "广州", "深圳"]

# 按顺序聚合name和age，并以列表形式返回结果

name_age = list(zip(name, age))

print(name_age)

[('张三', 17), ('李四', 19), ('王五', 18), ('赵六', 21)]

# 可以聚合多个可迭代对象

people = list(zip(name, age, city))

print(people)

[('张三', 17, '北京'), ('李四', 19, '上海'), ('王五', 18, '广州'), ('赵六', 21, '深圳')]

# 列表长度超过其它列表长度，则按顺序从左到右聚合，超出部分不聚合

gender = ["男", "男", "男", "男", "女", "女"]

people = list(zip(name, age, city, gender))

print(people)

[('张三', 17, '北京', '男'), ('李四', 19, '上海', '男'), ('王五', 18, '广州', '男'), ('赵六', 21, '深圳', '男')]

# 遍历zip返回的可迭代对象

for n, a, c, s in zip(name, age, city, gender):

print("name: {}, age: {}, city: {}, gender: {}".format(n, a, c, s))

name: 张三, age: 17, city: 北京, gender: 男

name: 李四, age: 19, city: 上海, gender: 男

name: 王五, age: 18, city: 广州, gender: 男

name: 赵六, age: 21, city: 深圳, gender: 男

# zip还可以解包

name_age = list(zip(name, age))

name2, age2 = zip(*name_age)

print(name2)

print(age2)

('张三', '李四', '王五', '赵六')

(17, 19, 18, 21)