python学习笔记2

列表

例：[1, 2, 2]

查询某元素下标  列表.index(元素)
修改列表元素    列表[下标] = 值
插入元素        列表.insert(下标, 元素)
追加元素        列表.append(元素)  将指定的元素，追加到列表的尾部
追加元素2       列表.extend([4, 5, 6])
删除元素        del 列表[下标]   列表.pop(下标)  列表.remove(元素)
清空列表        列表.clear()
统计某元素在列表中的数量 列表.count(查询元素)
列表总共元素数量 len(列表)

my_list = [1, 2, 3]
a = my_list.index(2)
print(f"2在列表中的下标是{a}")

my_list[0] = 9
print(f"修改后的列表为{my_list}")

my_list.insert(1, 6)
print(f"插入后的列表为{my_list}")

my_list.append(8)
print(f"追加后的列表为{my_list}")

my_list.extend([4, 5, 6])
print(f"追加一批后的列表为{my_list}")

del my_list[2]
my_list.pop(3)
my_list.remove(9)
print(f"删除元素后的列表{my_list}")

列表遍历

while循环  for循环

利用循环遍历列表

a = [1, 2, 3, 4, 5, 6]
# while循环方式
i = 0
while i < len(a):
    print(a[i])
    i += 1

# for循环方式
for j in a:
    print(j)

利用循环将1,10的偶数存入另一个列表

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
b = []
c = []
# for循环方式
for i in a:
    if i % 2 == 0:
        b.append(i)
print(b)

# while循环方式
j = 0
while j < len(a):
    if a[j] % 2 == 0:
        c.append(a[j])
    j += 1
print(c)

元组

一旦定义完成，就不可修改

变量名称 = (1, 2, 3)

定义空元组
变量名称 = ()
变量名称 = tuple()

定义单个元素的元组  变量名称 = (元素)

元组内可以存储字典、其他元组以及列表

student = ('小明', '11', ['a', 'b'])
print(f"年龄所在下标位置{student.index('11')}")
print(f"学生姓名为{student[0]}")
# 将元组中的列表中的a改为c
student[2][0] = 'c'
print(student)

字符串

字符串是一个无法修改的数据容器

字符串的替换  
字符串.replace(字符串1， 字符串2)   # 将字符串内的全部：字符串1，替换为字符串2

字符串的分割  
字符串.split(分割字符串)   # 按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

my_str = " x x da xue "
my_str_list = my_str.split(' ')
print(f"将字符串{my_str}进行切分后得到{my_str_list}")

my_str = "x r 星"
# 用|替换空格
new_my_str = my_str.replace(' ', '|')
print(new_my_str)
# 将字符串按照|分割
new2_my_str = new_my_str.split('|')
print(new2_my_str)

字符串的规整操作(去除前后空格)

字符串.strip()

序列

序列：内容连续、有序、可使用下表索引的一系列数据容器
数据切片：从一个序列中取出一个子序列

序列[起始下标:结束下标:步长]
步长为负数表示反向取,操作时需要下标反向

my_str = "世界你好，我要积极的面对这个世界"
new_str = my_str[9:4:-1]
print(new_str)

my_str = "世界你好，我要积极的面对这个世界"
new2_str = my_str[::-1][3:8]  #先倒序后切片
print(new2_str)

集合

集合的定义  集合不允许重复，乱序，不支持下标索引访问

变量名称 = {元素, 元素, 元素, 元素}

定义空集合
变量名称 = set()

集合添加新元素
集合.add(元素)

移除元素
集合.remove(元素)

取出元素(随机)
变量名称 = 集合.pop()

清空集合
集合.clear()

取出两个集合的差集

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取差集后的结果为{set3}")

消除两个集合的差集，在集合1内消除与集合2内相同的元素

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(set1)

集合的合并 

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"合并后的集合为{set3}")

统计集合的元素数量
len(集合)

将列表中的元素存入集合

list1 = [1, 2, 3, 4, 1, 2]
set1 = set()
for i in list1:
    set1.add(i)
print(set1)

字典

字典定义
{key: value, key: value, ....}
空字典定义 {}   dict{}

my_dict = {"小明": 99, "小红": 88}
my_dict2 = {}
my_dict3 = dict()
score = my_dict["小明"]
print(f"小明的考试分数是{score}分")

字典的嵌套

stu_score_dict = {
    "小明": {
        "语文": 99,
        "数学": 88
    }, "小红": {
        "语文": 98,
        "数学": 87
    }
}
print(f"学生的考试信息是{stu_score_dict}")
score = stu_score_dict["小明"]["语文"]
print(f"小明的语文成绩是{score}")

字典元素的新增
字典[key] = value  如果列表中没有key（关键字），则存入key和value。若key存在，就是修改value

删除元素  字典.pop(关键字)

my_dict = {"小明": 99, "小红": 88}
my_dict["小明"] = 66
print(my_dict)
score = my_dict.pop("小明")
print(f"删除一个元素后的结果是{my_dict},小明的成绩是{score}")

清空元素  字典.clear
获取全部key  字典.keys() 

字典的遍历

my_dict = {"小明": 99, "小红": 88}
# 方式1
keys = my_dict.keys() # 获取所有关键字
print(f"字典的关键字是{keys}")
for i in keys:
    print(f"字典的元素是{my_dict[i]}")

# 方式2
for j in my_dict:  # 用for遍历字典时，j获取的是字典中的关键字
    print(f"2字典的元素是{my_dict[j]}")

统计字典的元素数量  len()

数据容器

通俗来说，数据容器指能存储数据的容器，像是列表，元组，字典，集合等，都是数据容器。

统计数据容器

统计数据容器的最大元素 max(容器)
统计数据容器的最小元素 min(容器)
数据容器的通用转换 
list(容器)  str(容器)  tuple(容器) set(容器)

元素排序sorted(容器) 排序结果会变为列表对象

反向排序  sorted(容器， reverse=True)