前言

一、列表

1.什么是列表

类比其他语言的数组强大的地方在于列表中的元素可以是不同类型的，到底有多强，上代码。

my_list = [1, "xin", (1, ), {"yi"}, ["nice"], {"hello": "world"}]

• 1

说破大天也没有哪种语言能这么肆无忌惮, 一个列表里包含了int, str, 元祖, 列表, 字典…

2.列表的基本操作

<1>添加元素("增"append, extend, insert)

# 空列表
my_list = list()

# append 向列表队尾添加元素
my_list.append("罗罗诺亚")  # ["罗罗诺亚"]
my_list.append("索隆")  # ["罗罗诺亚", "索隆"]

# extend 将另一个集合中的元素逐一添加到列表中
b = ["三刀流", "奥义"]
my_list.extend(b)  # ["罗罗诺亚", "索隆", "三刀流", "奥义"]
my_list + b  # 有个偷懒的方法也是 ["罗罗诺亚", "索隆", "三刀流", "奥义"]

# insert insert(index, object) 在指定位置index前插入元素object
my_list.inset(0, "帅的一笔")  # ["帅的一笔", "罗罗诺亚", "索隆", "三刀流", "奥义"]

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

<2>修改元素(“改”)

# 修改元素只能通过下标修改哦
my_list = [1, 2, 3, 4]
my_list[0] = "修改"  # ["修改", 2, 3, 4]

• 1
• 2
• 3

<3>查找元素("查"in, not in, index, count)

# in, not in
# in（存在）,如果存在那么结果为true，否则为false
# not in（不存在），如果不存在那么结果为true，否则false
my_list = [1, 2, 3]
"1" in my_list  # False
"1" not in my_list  # True 

# index, count
# index和count与字符串中的用法相同
my_list.index(1, 0, 2)  # 第一个参数是要查找的元素, 第二三个是查找区间, 注意是左闭右开区间, 返回要查找元素的下标
my_list.count(1)  # 返回查找元素的个数 1

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

<4>删除元素("删"del, pop, remove)

# del：根据下标进行删除
del my_list[0]  # [1, 2]

# pop：默认删除最后一个元素
my_list.pop(1)  # [1]

# remove：根据元素的值进行删除（注意只能删除存在的元素）
my_list.remove(1)  # []

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

<5>排序(sort, sorted, reverse)

# sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。
my_list = [1, 4, 2, 3]  
my_list.reverse()  # [3, 2, 4, 1]

my_list.sort()  # [1, 2, 3, 4]

my_list.sort(reverse=True)  # [4, 3, 2, 1]

# sorted是保留原列表顺序, 也是默认由小到大
new_my_list = sorted(my_list)
# my_list 和 new_my_list 是完全独立的
print(my_list)  # [1, 4, 2, 3]
print(new_my_list)  # [1, 2, 3, 4]
print(sorted(my_list, reverse=True))  # [4, 3, 2, 1]

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

3.列表嵌套

# python 里的列表嵌套就是其他语言里的多维数组
my_list = [
	['北京大学','清华大学'],
	['南开大学','天津大学','天津师范大学'],
	['山东大学','中国海洋大学']
]

• 1
• 2
• 3
• 4
• 5
• 6

4.列表推导式

# 所谓的列表推导式，就是指的轻量级循环创建列表
my_list = [x for x in rang(5)]
print(my_list)  # [0, 1, 2, 3, 4]

# 其实看语法也能看出来, 就是把遍历的每个值添加到列表里
# 在循环过程中可以使用if
my_list = [x for x in range(1, 10) if x % 2 == 0]
print(my_list)  # [2, 4, 6, 8]

# 也可以多个for循环
my_list = [(x, y) for x in range(1, 3) for y in range(3)]
print(my_list)  # [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

二、元祖

python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

<1>定义元组

# 只有一个元素, 元素后面要有逗号
my_tuple = ("a", )

# 多个元素
my_tuple = ("a", "b")

• 1
• 2
• 3
• 4
• 5

<2>元祖不能修改(后续再说为何不能修改)

<3>count，index，与字符串和列表中的用法相同

三、字典

1.字典就是键值对，也可以理解为现在都在用的json就是python中的字典（切记是双引号）

my_dict = {
	"name": "索隆"
	"sex": "男"
}

• 1
• 2
• 3
• 4

2.字典的常见操作

<1>根据键访问值

name = my_dict["name"]  # 但是键不存在的时候就是报错, 空指针异常

name = my_dict.get("age")  # 不存在返回 None

name = my_dict.get("age", 10)  # 不存在返回默认值
name = 10 if my_dict.get("age") is None else my_dict.get("age")  # 这就是上面那种取值方式

• 1
• 2
• 3
• 4
• 5
• 6

<2>修改，添加元素

# 键存在是修改
my_dict["name"] = "路飞"  # {"name": "路飞", "sex": "男"}

# 键不存在是新增
my_dict["age"] = 18  # {"name": "路飞", "sex": "男", "age": 18}

• 1
• 2
• 3
• 4
• 5

<3>删除元素

# del 删除指定的元素
del my_dict["age"]  # {"name": "路飞", "sex": "男"}

# del 删除整个字典
del my_dict  # my_dict 已经被删除了, 再次访问就是未被定义

# clear清空整个字典
my_dict.clear()  # {}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

<4>len 测量字典中，键值对的个数

my_dict = {"name": "路飞", "sex": "男", "age": 18}
len(my_dict)  # 3

• 1
• 2

<5>keys 返回一个包含字典所有KEY的列表

my_dict = {"name": "路飞", "sex": "男", "age": 18}
my_dict.keys  # ["name", "sex", "age"]

• 1
• 2

<6>values 返回一个包含字典所有value的列表

my_dict = {"name": "路飞", "sex": "男", "age": 18}
my_dict.values  # ["路飞", "男", 18]

<7>items 返回一个包含所有（键，值）元祖的列表
```c
my_dict = {"name": "路飞", "sex": "男", "age": 18}
my_dict.items  # [("name", "路飞"), ("sex", "男"), ("age", 18)]

• 1
• 2
• 3
• 4
• 5
• 6
• 7

四、遍历

字符串、列表、元祖遍历一模一样

my_str = "hello world"
my_list = ["hello", "world"]
my_tuple = ("hello", "world")

# 最普通的遍历
for i in my_list:
	print(i)  # 依次打印里面的元素

# 带下标
for index, value in enumerate(my_list):
	print(index)  # 依次打印下标
	print(value)  # 依次打印里面的元素

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

字典

<1> 遍历字典的key（键）

my_dict = {"name": "路飞", "sex": "男", "age": 18}
for key in my_dict.keys():
	print(key)  # 依次打印字典里的key

• 1
• 2
• 3

<2> 遍历字典的value（值）

my_dict = {"name": "路飞", "sex": "男", "age": 18}
for value in my_dict.values():
	print(value)  # 依次打印字典里的value

• 1
• 2
• 3

<3> 遍历字典的项（元素）

my_dict = {"name": "路飞", "sex": "男", "age": 18}
for item in my_dict.items():
	print(item)  # 依次打印字典里项, 放在元祖里 ("name", "路飞")

• 1
• 2
• 3

<3> 遍历字典的key-value（键值对）

my_dict = {"name": "路飞", "sex": "男", "age": 18}
for key, value in my_dict.items():
	print(key)  # 依次打印字典里的key
	print(value)  # 依次打印字典里的value

• 1
• 2
• 3
• 4

总结

这就是python中常用的数据类型，感觉怎么样呀，够用了吗？