python学习第五天 列表，字典，元组

01:
列表的定义
列表-> 保存任意的数据类型(定义时候保存的什么类型 获取时候就是什么类型)
列表定义格式: 列表名 = [元素1, 元素2, …]
my_list = [“小明”, 22]
通过下标索引获取元素

02:
定义一个特殊的列表 -> 空列表
my_list = []
等价
my_list = list()
计算列表内部的元素个数
print(len(my_list))

03：
如果一个数据类型 支持下标索引获取内部的元素 就标识着这个数据类型为有序的

循环遍历

while循环
i = 0
while i < len(my_list):#要是等于，就会遍历my_str[5],但my_str[5]不存在
value = my_list[i] #通过下标索引获取对应的元素 #记住这是[],不是（）

print(value)
i += 1

for循环
for value in my_list:
print(value)

04：
可迭代对象指的是列表字符串元组等,是字符串不可更改

05：
添加元素(append, extend, insert)

append
把数据追加到列表的尾部
my_list.append(“hello”)

extend
把可迭代对象 进行最小单元拆分 依次把他们保存到列表中
my_list = [1, 2, 3]
my_list.extend(“abc”)
print(my_list)
结果就是：[1,2,3,a,b,c]

insert(插入数据)
my_list.insert(10, “呵呵”)
print(my_list)

06:
列表是可变的数据类型
修改元素查找元素(in, not in, index, count)

修改元素
my_list[1] = 200
print(my_list)

in查找
if 3 in my_list:
print(“存在”)

not in与in正好相反

index查找

count看存在数量

07：
删除元素(del, pop, remove)

my_list = [“hello”, “world”, 1, 3.14]

del
格式: del 列表名[下标索引]
del my_list[1] 我要删除my_list里面的元素
print(my_list)

pop
my_list.pop()
print(my_list)
（加索引，删除索引元素，不加删除最后一个元素）
格式1: 保存被删除的元素值 = pop(下标索引) 可以print输出出来查看删除的是谁
格式2: 保存被删除元素值 = pop() -> 删除列表中的最后一个元素
value = my_list.pop(1)
print(my_list)
print(value)

remove （上面那两个是利用下标索引，这个是直接删除元素）
格式: 列表名.remvoe(元素值)

08：
排序(sort, reverse)

sort
升序
my_list.sort() == my_list.sort(reverse=False)

降序 等于是排完序逆置
my_list.sort(reverse=True)

引申一些知识：

字符串 -> 字符串的逆置 abc -> [::-1] cba
还可以
利用 reverse 方法
my_list.reverse() （把当前列表的顺序逆置不保存原来的数据用这个）
print(my_list)

2:reversed
ret = reversed(my_list) （把当前列表的顺序逆置保存原来的数据用这个）
print(list(ret)) 折返回的是一个对象，应该进行数据类型转换
print(my_list) 这输出的是原来的

09：
列表的嵌套：
schoolNames = [[‘北京大学’, ‘清华大学’],
[‘南开大学’, ‘天津大学’, ‘天津师范大学’],
[‘山东大学’, ‘中国海洋大学’]]
name = schoolNames[1][1]
print(name)
结果：天津大学

10：
元组和列表很相似
不同点：
列表是可变的数据类型(可以增删改查)
元组是不可变的数据类型(只能)
相同点：
保存任意的数据类型，有序的数据类型

字符串 ” 或者 “” 或者三引号
列表 []
元组 ()
字典 {}

01:定义一个元组
my_tuple = (123, 3.14, True, “hello”)
print(my_tuple)
通过下标索引获取元素
pi = my_tuple[1]

02: 定义一个特殊的元组 -> 空元组
my_tuple = ()
等价
my_tuple = tuple()

03: 定义一个特殊的元组 -> 有且只有一个元素的元组
格式: 元组名 = (元素,)
my_tuple = (3.14,)

04: 查 (int not in index count)

in 在。查找
if 123 in my_tuple:（就是看看123在不在my_tuple里面）

not in不在，跟in相反

index查找位置，有输出下表索引，没有报错

count查找数量有几个
count = my_tuple.count(1)

05:循环遍历
他是一个可迭代对象 -> 循环遍历
my_tuple = (123, 3.14, True, “hello”, 1)
while i < len(my_tuple):
print(my_tuple[i])
i += 1

for循环
for value in my_tuple:
print(value)

06:验证元组是不可变的数据类型
my_tuple = (123, 3.14, True, “hello”, 1)
my_tuple[0] = 223
这个就会报错了，因为元租是不能被改变的。

07：为什么python提供了这种类型？
答：数据安全。

总结：
有序的数据类型
str
list
tuple
可变的数据类型
list
不可变的数据类型
str
tuple
支持len函数计算元素个数
str
list
tuple

11：
列表是有序的 极其关注顺序
字典是无序的数据类型 -> 不支持下标索引

01：字典的定义：
“name”: “小明” -> 键值对 (key value) -> 元素
“name” -> 键值 key
“小明” -> 实值 value
字典格式: 字典名 = {元素1, 元素2, ….}

my_dict = {“name”: “小明”, “no”: “001”, “age”: 22}
通过key 获取value
print(my_dict[“name”])
print(my_dict[“age”])
print(my_dict[“no”])
结果：
小明
001
22

02: 定义一个特殊的字典 -> 空字典
my_dict = {}
等价
my_dict = dict()

03: 在python中 任意数据类型都可以作为字典的key(键值) -> 键值中不能出现任何可变数据类型
key必须的是唯一的
my_dict = {3.14: “hello”}
print(my_dict[3.14])

04:一般在实际开发中 我们都是选择字符串作为字典的key

05:因为key是唯一的 如果程序员多写 只会保留一个，下面这个结果是小红。
key是唯一的 但是value是可以随意的
my_dict = {“name”: “小明”, “name”: “小红”}
print(my_dict)

定义字典
my_dict = {“name”: “小明”, “age”: 20}

<1>查看元素，通过key获取value

name = my_dict[“name”]

print(name)

<2>修改元素(如果key存在)
my_dict[“age”] = 23 相当如赋值，字典时无序的
print(my_dict)

<3>添加元素(如果key不存在)意思就是有键值就修改，没有就添加
my_dict[“test”] = “测试”
print(my_dict)

<4>删除元素
对字典进行删除操作，有以下几种：
del
clear()
del
格式: del 字典名[key] 通过key删除字典里的键值对
del my_dict[“age”]
print(my_dict)

clear 就是把键值对全部干掉。清空
my_dict.clear()
print(my_dict)

12：
定义字典
my_dict = {“name”: “小明”, “age”: 20}

<1>len() 也可以用来查字典键值对长度
l = len(my_dict)
print(l)

<2>keys
返回一个包含字典所有KEY的列表
keys_list = my_dict.keys()
print(list(keys_list)) 要把格式转换成list，因为返回的是对象
结果就是：name age

<3>values
返回一个包含字典所有value的列表，输出的也是无序的，不一定跟原来顺序一样
values_list = list(my_dict.values())
print(values_list)

<4>items
返回一个包含所有（键，值）元祖的列表，就是把键值对放到元组里，再把元组放到列表里
items_list = list(my_dict.items())
print(items_list)
结果：[(‘name’,’小明’)，(‘age’,’20’)]

<5>has_key （Python3 已取消)
可以使用in
if “name” in my_dict:
print(“存在”)

not in
if “test” not in my_dict:
print(“不存在”)

<6>
通过key 获取字典中的value值的方式有几种?
定义字典
my_dict = {“name”: “小明”, “age”: 20}
01:
my_name = my_dict[“name”]

02: setdefault
如果key键值存在 那么将获取对应的value
如果key不存在 那么将返回默认值（下面哈哈就是默认值） 会把这个key和默认值组成一个新的键值对添加到字典中
my_name = my_dict.setdefault(“name1”, “哈哈”)
print(my_name)
print(my_dict)

03: get
如果key存在 那么将获取对应的value
如果key不存在 那么将返回默认值 字典不会发生任何改变
my_name = my_dict.get(“name1”, “哈哈”)
print(my_name)
print(my_dict)