列表
1.【重点】列表的定义和使用
“”" 列表定义的格式：
列表变量的名字 = [元素1, 元素2, ……]
a = list() 这种也可以 定义一个空列表
使用格式：
列表变量[位置]
位置：也叫下标、索引 “”"
列表定义
name_list = ['mike', 'yoyo', 'rock', 'lily']
# 0 1 2 3
# 索引位置 默认是从0开始，最后一个元素的索引为-1
# -1
print(name_list, type(name_list))
# 最后一个元素取出来
print(name_list[3])
print(name_list[-1])
# 访问列表元素，不要超出范围，不要越界，越界就报错这个
print(name_list[4]) # IndexError: list index out of range
列表的嵌套
● 列表中还包含列表
# 0 1 0 1 0 1
school_list = [['北大', '清华'], ['复旦', '交大'], ['中大', '华工']] # 列表的嵌套
# 0 1 2
# 取出第 2 个元素，也就是索引为1的元素
print(school_list[1]) # ['复旦', '交大']
# 先取出索引为1的元素，再继续索引为1的元素
# school_list[1] = ['复旦', '交大']
print(school_list[1][1]) # 交大
列表常用操作
3.1追加删除元素
“”"
列表.append(值) 在末尾追加数据
列表.insert(索引， 值) 在指定索引加数据
列表.extend(值) 就是类似列表合并之类
列表.remove(值) 删除第一个出现的指定数据
“”"
my_list = [1, 2, 3]
# 增加一个元素，值为4
my_list.append(4)
print(my_list) # [1, 2, 3, 4]
# 合并元组
a = [1, 2, 3, 4]
a.extend((7, 8))
print(a) #[1, 2, 3, 4, 6, 7, 8]
# 删除值为2的元素
my_list.remove(2)
print(my_list) # [1, 3, 4]
# 指定位置添加元素
a = [1, 2, 3, 4]
a.insert(0, 100)
print(a) # [100, 1, 2, 3, 4, 6]
3.2 修改查询元素
“”" 列表[索引] = 值 修改指定索引的数据，数据不存在会报错 列表[索引] 根据索引取值，索引不存在会报错
len(列表) 列表长度(元素个数) if 值 in 列表: 判断列表中是否包含某个值 “”"
my_list = [1, 2, 3, 4]
# 0 1 2 3
# 最后一个元素，修改为5
my_list[-1] = 5 # 有赋值就是修改
print(my_list) # [1, 2, 3, 5]
# 访问索引为1的元素
print(my_list[1]) # 2 # 没有赋值就是查询
# len(列表) 列表长度(元素个数)
n = len(my_list)
print(n) # 4
print('=' * 50)
my_list = [1, 2, 3, 4]
print(my_list)
判断3，是否在列表中
# 3 in my_list # 判断3是否在列表中，如果在，结果为True
print(3 in my_list) # True
print(3 not in my_list) # False
if 3 in my_list:
print('3在列表中')
else:
print('3不在列表中')
3.3 列表排序
在Python中，list.sort() 是就地排序（in-place sorting）方法，它会直接修改原始列表，并返回 None。
因此，当你尝试使用 print(my_list.sort()) 或将 my_list.sort() 赋值给变量时，都会得到 None。
如果你想获得排序后的列表而不修改原始列表，可以使用 sorted() 函数：
my_list = [1, 3, 4, 2, 7, 6]
# 使用 sorted() 函数得到排序后的新列表
sorted_list = sorted(my_list)
print(sorted_list) # [1, 2, 3, 4, 6, 7]
# 原始列表保持不变
print(my_list) # [1, 3, 4, 2, 7, 6]
# 使用 sorted() 函数得到降序排序后的新列表
sorted_desc_list = sorted(my_list, reverse=True)
print(sorted_desc_list) # [7, 6, 4, 3, 2, 1]
# 原始列表保持不变
print(my_list) # [1, 3, 4, 2, 7, 6]
my_list = [1, 3, 4, 2, 7, 6]
# 列表.sort() 升序排序
my_list.sort()
print(my_list) # [1, 2, 3, 4, 6, 7]
# reverse=True, 降序排序
my_list.sort(reverse=True)
print(my_list) # [7, 6, 4, 3, 2, 1]
- 列表的遍历
遍历，从头开始找，直到结束 name_list = [‘mike’, ‘yoyo’, ‘rock’, ‘lily’]
while循环遍历
# 1. 定义条件变量i = 0
i = 0
# 2. while i < 列表元素个数:
while i < len(name_list):
# 3. 取出某个元素，打印
value = name_list[i]
print(value)
# 4. 条件变量的修改
i += 1
for 循环遍历
for i in name_list:
print(i)
** if…in 和 for…in 的区别**
if…in：判断某个元素是否在列表中，如果在，if的条件为True
for…in：从头到尾 依次从 列表 中取出 每一个元素，这个元素给name赋值
name_list = ['mike', 'yoyo', 'rock', 'lily']
if 'mike' in name_list:
print('mike在列表中')
for v in name_list:
print(v)
for…else的使用
● 和while的情况是一样的
name_list = ['mike', 'yoyo', 'rock', 'lily']
for v in name_list:
print(v)
# break
else:
print('上面的for没有break，执行完for后，就会执行else')
元组
1.【重点】元组的定义和使用
2.【知道】元组和列表的区别
● 元组标志为：（）
● 元组只有一个元素的时候，格式: (元素,)
● 元组的元素只读，不能改
列表：列表变量 = [元素1, 元素2, ……]
元组：元组变量 = (元素1, 元素2, ……)
name_tuple = ('mike', 'yoyo', 'rock', 'lily')
print(name_tuple, type(name_tuple))
取出第0个元素
print(name_tuple[0])
#元组只有一个元素的时候，格式: (元素,)
num_tuple = (250,)
#元组的元素只读，不能改
#name_tuple[0] = 'tom' # TypeError: 'tuple' object does not support item assignment
#循环遍历和列表一样, 元组只能查找
for v in name_tuple:
print(v)
字典
1.字典的定义和使用
● 使用字典元素，{}里面写的是健
● 健是唯一的，且键的值只能是不可变类型，字符串，元组等
“”"
字典定义格式：
字典变量 = {k1:v1, k2:v2,……}
取出元素的值：
字典变量[键值]
“”"
字典的定义
info = {'name':'mike', 'age':35, 'city':'sz'}
print(info, type(info)) # {'name': 'mike', 'age': 35, 'city': 'sz'} <class 'dict'>
#取出元素的值：字典变量[键值]
print(info['age'])
2.1增加删除元素
“”"
字典[键] = 值 键不存在，会添加键值对
字典.pop(键) 删除指定键值对,返回被删除的值,如果键不存在,会报错
“”"
#字典定义
info = {'name':'mike', 'age':35, 'city':'sz'}
增加元素
info['sex'] = 'male'
print(info) # {'name': 'mike', 'age': 35, 'city': 'sz', 'sex': 'male'}
删除元素，他会把删除这个key之后的字典返回
info.pop('age')
print(info) # {'name': 'mike', 'city': 'sz', 'sex': 'male'}
修改元素
方式一:info['sex'] = 'woman'
方式二:info.update(**{"douban_acq_url": base_dict.get("douban_acq_url")})
2.2 修改查询元素
“”"
字典[键] = 值 键存在，会修改键值对的值, 键不存在，增加元素
字典[键] 根据键取值，键值对不存在会报错
字典.get(键) 根据键取值，键值对不存在返回None, 不会报错
“”"
info = {'name':'mike', 'age':35, 'city':'sz'}
info['age'] = 18
print(info) # {'name': 'mike', 'age': 18, 'city': 'sz'}
print(info['city']) # sz
#KeyError: 'sex', 键不存在，报错
print(info['sex'])
print(info.get('sex')) # 不存在，返回None
2.3【重点】遍历字典
“”"
#遍历字典, 获取所有的键值对 (键, 值) key, value for k, v in 字典变量.items():
print(k, v) “”"
遍历字典，获取所有的key,for key in 字典变量.keys():
print(key)
遍历字典，获取所有的values,for value in 字典变量.keys():
print(value）
info = {'name':'mike', 'age':35, 'city':'sz'}
for key, value in info.items():
print(key, value)
字符串
1.字符串的定义和使用
“”" 字符串变量 = ‘字符串内容’ 说明：可以是单引号、双引号、三引号
> 字符串和元组一样，元素不能修改 “”"
my_str = ‘hello python’
my_str = “hello python”
my_str = ‘’‘hello python’‘’
取某个元素，和列表一样
print(my_str[6])
# my_str[6] = 'x' # TypeError: 'str' object does not support item assignment
遍历取所有元素
for v in my_str:
print(v)
2.f-strings 字符串格式化
● Python 3.6之后引入的新特性
print(f"我的名字叫做{yuanbao}")
print("我{}".format("yb"))
python2格式化
print("我的 %s" % ("元寶"))
3. 字符串常用操作
查找
“”" 字符串.find(目标字符串, 开始索引, 结束索引) 在指定范围内, 查询目标字符串的索引, 不存在返回-1 “”"
```python
str1 = 'hello abc'
在str1字符串中，查找’abc‘字符串，返回找到字符串所对应的索引
index = str1.find('abc') # 默认从头到结尾查找
index = str1.find('abc', 0, 5)
print(index)
# 如果没有找到，返回-1
index = str1.find('mike')
print(index)
替换
“”" 字符串.replace(原内容, 新内容, 替换次数) 返回一个替换了原内容的新字符串，可以指定替换次数 “”"
str1 = ‘abc hello abc’
源字符串里的abc，替换为python，返回值才是替换后的内容
new_str = str1.replace('abc', 'python') # 默认全部替换
new_str = str1.replace('abc', 'python', 1) # 指定替换1次
print('str1 =', str1)
print('new_str =', new_str)
**分割
** 字符串.split(分割符) 以分割符拆分字符串, 返回列表
str1 = 'abc,hello,mike,python'
str1中字符串内容以','分隔，返回字符串列表['abc', 'hello', 'mike', 'python']
temp = str1.split(',')
print(temp) # ['abc', 'hello', 'mike', 'python']
**拼接
** 字符串 + 字符串 拼接两个字符串
字符串.join(字符串列表) 以字符串来连接字符串列表中每个元素，合并为一个新的字符串, 返回新的字符串
多个字符串连接再一起
str1 = 'hello ' + 'python'
print(str1)
str2 = '1' + '1' # ’11‘
temp = 1 + 1 # 2
print(str2, type(str2))
print(temp, type(temp))
temp_list = ['abc', 'hello', 'mike', 'python']
把列表中的字符串元素以某个连接符连接起来
j_str = '^_@'
new_str = j_str.join(temp_list) # 返回一个连接后新的字符串
print(new_str) # abc^_@hello^_@mike^_@python
字符串的切片操作
“”"
s = ‘python’
012345
字符串[开始索引:结束索引:步长]
0. 步长默认为1，步长理解为走几步，正数从左往右，负数从右往左
s[::] python
s[::2] pto
s[::-1] nohtyp
s[::-2] nhy
1. 字符串[开始索引:结束索引] 开始索引 ~（结束索引-1）
s[0:2] py, 只要指定结束索引，取到结束索引的上一个
s[0:5] pytho
s[0:] python
2. 字符串[开始索引: ] 开始索引 ~ 结束索引，末尾索引不写，默认能取到末尾那个索引
s[0:] python
3. 字符串[ :结束索引] 0 ~（结束索引-1），开始索引不写，默认从第0个元素开始
“”"
s = ‘python’
012345
-1
截取从 y ~ n 位置 的字符串
print(s[1:])
截取从 y ~ o 位置 的字符串
print(s[1:5])
print(s[1:-1])
截取从 h ~ 末尾 的字符串
print(s[3:])
截取从 开始 ~ h 位置 的字符串
print(s[0:4])
print(s[:4])
#从开始位置，每隔一个字符截取字符串，也就是说走2步
print(s[::2])
#截取字符串末尾两个字符
print(s[4:])
print(s[-2:])
#字符串的逆序（面试题）
print(s[::-1])
集合
通过set对list中的元素去重
集合：元素不会重复，{元素1，元素2……}
定义集合 my_set = {1, 3, 1, 4, 1,5}
print(my_set, type(my_set))
print(‘=’ * 50)
通过集合完成对列表去重功能, 把类型转换为集合后，即可完成去重功能
my_list = [3, 5, 3, 5, 1, 3, 1, 4]
temp_set = set(my_list) # 集合类型
print(temp_set)
my_list = list(temp_set)
print(my_list) # [1, 3, 4, 5]
2.list、tuple、set之间类型转换
list(x)
tuple(x)
set(x)
转换为集合为了去重
六、公共语法
1.【知道】容器公共语法：内置函数、切片、运算符
通过len获取容器类型的元素个数
num_list = [1, 2, 3, 4]
my_str = 'hello'
info = {'name':'mike', 'age':18}
print(len(num_list), len(my_str), len(info))
print(max(num_list))
字符串、列表、元组都支持切片操作
char_list = ['a', 'b', 'c', 'd']
# 0 1 2 3
print(char_list[1:3])
print(char_list[::-1])
运算符
+：拼接，同类型的容器
# 字符串拼接合并
str1 = 'abc' + '123'
print(str1)
# 列表元素拼接合并
temp_list = [1, 2] + [5, 6, 7]
print(temp_list)
# *: 复制
print('=' * 50)
print([1, 2] * 10)
4738
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
