01.recode
列表(list) - 有序、可变
[12, 34, 56]
列表元素的要求：任何类型的数据都可以作为列表元素
获取单个元素、获取部分元素(切片)、遍历
相关运算: +, *, ==/!=, in / not in, len(), list(), max(), min()
name = '张三'
list1 = [12, 'abc', True, name, max('abcz')]
print(list1[-1])
z
补充： == 和 is
== - 判断两个数据的值是否相等
is - 判断地址是否相等
python数据存储:1.给变量赋值的时候，如果数据的类型是数字或者字符串，不会直接开辟空间存数据，而是现在数字字符串对应的缓存区里面去查看是否已经存储过对应的数据。如果已经存了，直接将之前的数据对应的地址赋给变量。如果没有存储才会开辟空间存储数据。其他类型的数据，都是直接开辟空间存储数据。然后再把地址返回
2.容器类型中的元素，在容器中不是直接存的值，而是元素值对应的地址
list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = list1
print(list1 == list2)
print(list1 is list2)
print('===:',list1[0] is list2[0])
print(list1 is list3)
True
False
===: True
True
number1 = 10
number2 = 10
print(number1 is number2)
True
02.列表相关方法
1.列表赋值
a.直接使用一个列表变量给另一个列表变量赋值，赋的是地址。
赋完值之后，对其中一个列表进行增删改，会影响另一个列表
b.如果赋值的时候赋的列表的切片或者拷贝,会产生新的地址，然后使用新的地址赋值。赋完值之后，两个列表相互之间不影响
# 现象1：
list1 = [1, 2, 3]
list2 = list1
list2.append(100)
print(list1) # [1, 2, 3, 100]
list1 = [1, 2, 3]
list2.append(200)
print(list1)
[1, 2, 3, 100]
[1, 2, 3]
# 现象2：
list1 = [1, 2, 3]
list2 = list1[:]
list2.append(100)
print(list1) # [1, 2, 3]
[1, 2, 3]
2.列表中的方法
1.列表.count(元素) - 获取指定元素在列表中出现的次数
numbers = [100, 34, 90, 89, 100, 7, 100, 18]
print(numbers.count(100))
3
2.列表.extend(序列) - 将序列中所有的元素都添加到列表中
numbers.extend(['abc', 'hello'])
print(numbers)
numbers.extend('world')
print(numbers)
numbers.extend(range(11, 15))
print(numbers)
[100, 34, 90, 89, 100, 7, 100, 18, 'abc', 'hello']
[100, 34, 90, 89, 100, 7, 100, 18, 'abc', 'hello', 'w', 'o', 'r', 'l', 'd']
[100, 34, 90, 89, 100, 7, 100, 18, 'abc', 'hello', 'w', 'o', 'r', 'l', 'd', 11, 12, 13, 14]
3.列表.index(元素) - 获取指定元素的下标
注意:a.如果元素有多个，只去第一个的下标
b.如果这个元素不存在，会报错(ValueError)
numbers = [3, 1, 2, 3, 4, 5, 3]
print(numbers.index(3)) # 0
# print(numbers.index(33)) # ValueError: 33 is not in list
0
4.列表.reverse() - 反向列表(将列表元素倒序)
numbers = [19, 89, 2, 8, 98, 10, 32]
numbers.reverse()
print(numbers)
[32, 10, 98, 8, 2, 89, 19]
5.列表.sort() - 对列表进行升序排序(从小到大)
列表.sort(reverse=True) - 对列表进行降序排序(从大到小)
注意：列表的要求：a.列表的元素类型必须一样 b.元素支持比较运算符
numbers = [19, 89, 2, 8, 98, 10, 32]
numbers.sort()
print(numbers)
[2, 8, 10, 19, 32, 89, 98]
numbers = [19, 89, 2, 8, 98, 10, 32]
numbers.sort(reverse=True)
print(numbers)
[98, 89, 32, 19, 10, 8, 2]
names = ['路飞', '娜美', '山治', '罗宾', '弗兰克', '乔巴', '佐罗']
names.sort()
print(names)
['乔巴', '佐罗', '娜美', '山治', '弗兰克', '罗宾', '路飞']
6.列表.clear() - 清空列表
names = ['路飞', '娜美', '山治', '罗宾', '弗兰克', '乔巴', '佐罗']
names.clear()
print(names)
[]
# 注意: 清空列表尽量使用clear()
# names = ['路飞', '娜美', '山治', '罗宾', '弗兰克', '乔巴', '佐罗']
# names = []
# print(names)
7.列表.copy() - 将列表中元素直接赋值一份产生一个新的列表。和列表[:]效果一样
注意: 这儿的拷贝是浅拷贝
list1 = [1, 2, 3]
list2 = list1.copy()
print(list2)
print(list1 is list2) # False
[1, 2, 3]
False
03.浅拷贝和深拷贝
import copy
# copy.copy(对象) - 浅拷贝 （直接拷贝元素的值产生一个新的地址）
# copy.deepcopy(对象) - 深拷贝(不会直接复制地址，而是将地址对应的值拷贝一份产生新的地址)
numbers1 = [1, 2, 3]
numbers2 = [10, 20, 30]
list1 = [numbers1, numbers2]
print('1.浅拷贝：')
list2 = list1.copy()
print('修改前list1:', list1)
print('修改前list2:', list2)
print('针对list1进行修改')
list1.append(111)
list1[0].append(100)
print('修改后list1:', list1)
print('修改后list2:', list2)
numbers1 = [1, 2, 3]
numbers2 = [10, 20, 30]
list1 = [numbers1, numbers2]
print('2.深拷贝')
list2 = copy.deepcopy(list1)
print('修改前list1:', list1)
print('修改前list2:', list2)
print('针对list1进行修改')
list1.append(111)
list1[0].append(100)
print('修改后list1:', list1)
print('修改后list2:', list2)
1.浅拷贝：
修改前list1: [[1, 2, 3], [10, 20, 30]]
修改前list2: [[1, 2, 3], [10, 20, 30]]
针对list1进行修改
修改后list1: [[1, 2, 3, 100], [10, 20, 30], 111]
修改后list2: [[1, 2, 3, 100], [10, 20, 30]]
2.深拷贝
修改前list1: [[1, 2, 3], [10, 20, 30]]
修改前list2: [[1, 2, 3], [10, 20, 30]]
针对list1进行修改
修改后list1: [[1, 2, 3, 100], [10, 20, 30], 111]
修改后list2: [[1, 2, 3], [10, 20, 30]]
04.元祖
1.什么是元祖（tuple）
元祖就是不可变的列表。（有序，不可变）
有序 - 可以通过下标获取元素
不可变 - 不支持增、删、改
2.元祖的字面量: 通过小括号将多个元素括起来，多个元素之间用逗号隔开
tuple1 = (1, True, 'abc', [1, 2], 1)
print(tuple1)
(1, True, 'abc', [1, 2], 1)
a.只要一个元素的元祖: 在元素的后面必须加一个逗号
tuple2 = (10,)
print(tuple2, type(tuple2))
(10,) <class 'tuple'>
b.直接将多个数据用逗号隔开，不用括号括起来。还是一个元祖值
tuple3 = 1, 2, 3, 'abc'
print(tuple3, type(tuple3))
(1, 2, 3, 'abc') <class 'tuple'>
c.获取元祖元素
tuple4 = (10, 20)
print(tuple4[0], tuple4[-2])
10 10
d.可以通过变量个数和元祖元素个数保持一致来获取元祖中的每个元素
x, y = tuple4 # x, y = 10, 20
print(x, y)
10 20
通过在变量名前加,获取没有的变量获取到的元素的剩下的部分。以列表的形式返回
tuple5 = ('余婷', 98, 90, 99, 87, 78)
name, *scores = tuple5
print(name, scores) # '余婷' [98, 90, 99, 87, 78]
余婷 [98, 90, 99, 87, 78]
name, number, *scores = tuple5
print(name, number) # '余婷' 98
print(scores) # [90, 99, 87, 78]
余婷 98
[90, 99, 87, 78]
*list1, num = tuple5
print(list1, num) # ['余婷', 98, 90, 99, 87] 78
['余婷', 98, 90, 99, 87] 78
num1, *list1, num2 = tuple5
print(num1, num2) # 余婷 78
print(list1) # [98, 90, 99, 87]
余婷 78
[98, 90, 99, 87]
了解
tuple1 = (1, 2, 3)
print(*tuple1)
list1 = ['aa', 'bb', 'cc']
# a = list1[0]
# b = list1[1]
# c = list1[2]
# *list1 == a b c
print(*list1)
1 2 3
aa bb cc
3.获取元祖元素和列表获取列表回去列表元素一模一样
tuple1 = 1, 2, 3, 4, 5
print(tuple1[1])
print(tuple1[:3])
2
(1, 2, 3)
for item in tuple1:
print(item)
1
2
3
4
5
4.相关运算和列表一样
+, *, in/not in, len(), tuple(), max(), min()
print((1, 2) + ('a', 'n'))
print((1, 2) * 3)
print(1 in (1, 2))
print(len((1, 2, 4)))
print(max((1, 89, 0)))
print(min((1, 89, 0)))
(1, 2, 'a', 'n')
(1, 2, 1, 2, 1, 2)
True
3
89
0
5.元祖相关的方法： 只有列表中的count和index
tuple1 = (1, 2, 3, 4, 3, 5)
print(tuple1.count(3))
print(tuple1.index(4))
2
3
05.认识字典
1.什么是字典（dict）
字典是python中内置的容器类的数据类型,可变，无序的。字典的元素是键值对
2.字典的字面量：使用大括号括起来，大括号中是键值对，多个键值对之间用逗号隔开
键值对- 键:值
键(key) - 不可变的；唯一的 (一般使用字符串作为key)
值(value) - 任何类型的数据
dict1 = {'aa': 100, 10: 'abc', (10, 20): 'hello'}
列表和字典不能作为key
dict2 = {{'a': 1}: 100, 10: 'abc', (10, 20): 'hello'} # TypeError
key是唯一的
dict2 = {'aa': 100, 'aa': 200, 'bb': 300}
print(dict2) # {'aa': 200, 'bb': 300}
{'aa': 200, 'bb': 300}
什么时候使用字典:
如果一个容器里面存储的数据是不同意义的数据(数据之间需要区分),就使用字典
# 用一个变量来存储一个学生的信息：姓名、年龄、电话、成绩、学号
student = ['小明', 28, '1627399992', 30, '1982001', 98]
print(student[0])
小明
student = {'name': '小明', 'age': 28, 'tel': '1627399992', 'score': 30, '学号':'1982001'}
print(student['name'])
小明
06.字典的增删改查
1.查(获取字典的值)
a.获取单个值
字典[key] - 获取字典中key对应的值 (注意：如果key不存在，会报错:KeyError)
字典.get(key) - 获取字典中key对应的值 (如果key不存在，不会报错，并且会返回一个默认值None)
None是python中的关键字，表示一个特殊值，(没有、空的意思)
dog1 = {'name': '旺财', 'age': 3, 'color': '黄色', 'type': '土狗'}
print(dog1['name'])
print(dog1['color'])
# print(dog1['sex']) # KeyError: 'sex'
print(dog1.get('age'))
print(dog1.get('type'))
print(dog1.get('sex'))
旺财
黄色
3
土狗
None
b.遍历
直接遍历字典拿到的是字典中所有的key
for key in dog1:
print(key, dog1[key])
name 旺财
age 3
color 黄色
type 土狗
同时获取key和value（看着方便但是性能差，内存消耗多）
print(dog1.items())
dict_items([('name', '旺财'), ('age', 3), ('color', '黄色'), ('type', '土狗')])
for key, value in dog1.items():
print(key, value)
name 旺财
age 3
color 黄色
type 土狗
2.增(添加键值对)
字典[key] = 值 - 当key不存的时候，就是在字典中添加键值对
dict1 = {'a': 100}
dict1['b'] = 200
print(dict1)
{'a': 100, 'b': 200}
字典1.update(序列) - 将序列中的元素转换成键值对，然后再添加到字典1中
注意:在这儿的序列要求是能够转换成字典的序列。序列中的元素是只有两个元素的小序列
dict1 = {'a': 100, 'b': 200}
# 当key值有重名的时候，会用序列中键值对对应的值，更新原字典的key对应的值
dict1.update({'aa': 10, 'bb': 20, 'a': 'abc'})
print(dict1)
{'a': 'abc', 'b': 200, 'aa': 10, 'bb': 20}
dict1.update([[1, 2], ['a', 2], [2, 'b']])
print(dict1)
{'a': 2, 'b': 200, 'aa': 10, 'bb': 20, 1: 2, 2: 'b'}
dict1.update([('aaa', 100), [12, 200]])
print(dict1)
{'a': 2, 'b': 200, 'aa': 10, 'bb': 20, 1: 2, 2: 'b', 'aaa': 100, 12: 200}
3.改(修改key对应的值)
字典[key] = 值 - 当key存在的时候，就是修改key对应的值
dict1 = {'a': 10, 'b': 20}
dict1['a'] = 100
print(dict1)
{'a': 100, 'b': 20}
4.删(删除键值对)
a. del 字典[key] - 删除字典中key对应的键值对
person = {'name': '张三', 'age': 30, 'sex': '男'}
del person['sex']
print(person)
{'name': '张三', 'age': 30}
b.字典.pop(key) - 取出字典中key对应的值（删除整个键值对）
person = {'name': '张三', 'age': 30, 'sex': '男'}
age = person.pop('age')
print(person, age)
{'name': '张三', 'sex': '男'} 30
person = {'name': '张三', 'age': 30, 'sex': '男'}
# 删除最后一个键值对(取出最后一个键值对, 以元祖的形式返回) - 无意义
value = person.popitem()
print(person, value)
{'name': '张三', 'age': 30} ('sex', '男')
dict1 = {}
dict1["name"] = 'abc'
print(dict1)
print(dict1["name"])
{'name': 'abc'}
abc
07.字典的相关方法
1.字典不支持+和*
1. in 和 not in
key in 字典 - 判断字典中是否存在指定的key
dict1 = {'a': 12, 'b': 20, 'c': 30}
print('a' in dict1)
True
