Python学习之路
神乃シズクのPython学习之路
Python常用数据结构
列表
定义、创建和删除
创建
a_list = []\nb_list = [20, "张三", 177.6]\nc_list = list(range(10))\nprint(a_list)\nprint(b_list)\nprint(c_list)\n\n\n\n\n\n
输出结果
直接用[]创建
使用list()函数将元组、range对象、字符串转换为列表
删除
通过del命令删除列表
a_list = [1,2,3]\ndel a_list
元素的访问
创建列表时，将会开辟一块连续空间
正向索引
0，1，2，3...
反向索引
-1，-2，-3，-4...
a_list = list(range(2,10))\nprint(a_list)\nprint(a_list[6])\nprint(a_list[-2])\nls = [2022,"bat",[10,'软件工程'],2023]\nprint(ls[2][-1][0])
输出结果
切片操作
a_list = list(range(1,10))\nprint(a_list[::1])\nprint(a_list[:1:])\nprint(a_list[1::])\nprint(a_list[::-1])\nprint(a_list[:-1:])\nprint(a_list[-1::])\nprint(a_list[::])
输出结果
输入代码解释
内容的修改操作
对单个元素进行修改
a_list = list(range(1,10))\na_list[2]="ABC"\nprint(a_list)\na_list[4]=[11,12,13,14]\nprint(a_list)
输出结果
对某个连续区域进行修改
a_list=list(range(1,10))\na_list[1:6]=[15,20,25,45,80]\nprint(a_list)
输出结果
a_list=list(range(1,10))\na_list[1:3]=[15,20,25,45,80]\nprint(a_list)
输出结果
a_list = list(range(1, 10))\na_list[1:6:2] = [15,20,25]\nprint(a_list)
输出结果
常见方法
index(object)
获取列表中某个对象第一次出现的位置，不存在时报错ValueError
a_list=[3,5,7,3,6,2,9,6,8,4,3]\nprint(a_list.index(6))\nprint(a_list.index(6,5,-1))
输出结果
index（value,start,end）
count(object)
统计列表中某个对象出现的次数，不存在时返回0
a_list=[3,5,7,3,6,2,9,6,8,4,3]\nprint(a_list.count(6))
输出结果
append(object)
在列表的末尾添加一个对象
a_list=[3,5,7,3,6,2,9,6,8,4,3]\na_list.append([33,44,55])\nprint(a_list)
输出结果
extend(iterable)
将一个可迭代对象合并到列表中去，注意和append()方法的区别
a_list=[3,5,7,3,6,2,9,6,8,4,3]\na_list.extend([33,44,55])\nprint(a_list)
输出结果
insert(index, object)
在列表的指定位置插入一个元素，该位置及后面的元素依次往后移动
a_list=[3,5,7,3,6,2,9,6,8,4,3]\na_list.insert(2,"ABC")\nprint(a_list)
输出结果
sort(key, reverse)
对列表中的元素进行排序，前提是元素之间可比较，否则会报错，默认为升序 注意: sort()方法为永久性排序。
a_list=[3,5,7,3,6,2,9,6,8,4,3]\na_list.sort(reverse=True)\nprint(a_list)
输出结果
sorted()
a_list = [3,5,7,3,6,2,9,6,8,4,3]\nb_list = sorted(a_list)\nprint("a_list:", a_list)\nprint("b_list:", b_list)
输出结果
pop([index])
删除列表中指定位置的元素，默认删除最后一个，并返回删除的元素
a_list = [3,5,7,3,6,2,9,6,8,4,3]\nprint(a_list)\nprint(a_list.pop()) # 删除最后一个元素\nprint(a_list)\nprint(a_list.pop(1)) # 删除第2个元素\nprint(a_list)
输出结果
remove(object)
删除列表中第一次出现的指定元素
a_list = [3,5,7,3,6,2,9,6,8,4,3]\nprint(a_list)\nprint(a_list.remove(7))\nprint(a_list)
输出结果
reverse()
将列表进行逆序
a_list = [3,5,7,3,6,2,9,6,8,4,3]\nprint(a_list)\na_list.reverse()\nprint(a_list)
输出结果
reversed()
a_list = [3,5,7,3,6,2,9,6,8,4,3]\nprint(a_list)\n# reversed()生成一个新的迭代器\nb_list = reversed(a_list)\nprint(a_list)\n# 使用list函数转换新迭代器\nprint(list(b_list))
输出结果
clear()
清空列表内容
a_list = [3,5,7,3,6,2,9,6,8,4,3]\nprint(a_list)\na_list.clear()\nprint(a_list)
输出结果
copy()
将列表内容复制一份，是一种浅拷贝
a_list = [3,5,7,3,6,2,9,6,8,4,3]\nb_list = a_list.copy()\nprint(a_list)\na_list[1]="ABC"\nprint(a_list)\nprint(b_list)
输出结果
常见操作
len(列表)
获取列表中元素的个数
max(列表)
获取列表中最大的元素，前提是列表中元素可比较
min(列表)
获取列表中最小的元素，前提是列表中元素可比较
sum(列表)
对列表中的元素进行求和，前提是列表中元素可执行加法运算
reversed(列表)
将列表进行逆序，返回一个可迭代对象
sorted(列表，key, reverse)
对列表中的元素进行排序，返回一个新列表。前提是元素之间可比较，否则会报错，默认为升序
列表1 + 列表2
实现两个列表的合并，并返回一个新的列表
列表 * 整数
将列表中的内容复制若干份，并返回一个新的列表
enumerate(列表)
生成一个枚举对象，每个元素为索引和值形成的元组
school_list = ['软件与物联网工程学院', '信息管理学院', '统计学院', '虚拟现实产业学院']\nprint(school_list)\nb_list = list(enumerate(school_list))\nprint(b_list)\nfor index, school_name in enumerate(school_list):\n print(index, school_name)
输出结果
zip(列表1, 列表2)
生成一个zip对象，每个元素为列表中对应位置元素形成的元组
names = ['张军', '李华', '王芳', '匡明']\nstu_no = ['0001', '0002', '0003']\ntalls = [168, 173, 166]\nstu_list = zip(stu_no, names, talls)\nfor name, no, tall in stu_list:\n print("%s: %s, %d cm." %(no, name, tall))
输出结果
当序列长度不同时, 函数zip()将在最短的序列用完后停止拼接。
推导式
列表推导式利用已有列表快速生成满足特定需求的列表。列表推导式在逻辑上相当于一个循环，只是形式更加简洁。
元组
定义、创建和删除
定义
元组属于不可变序列，一旦创建，不可修改里面的元素。元组中元素放在一对圆括号“()”中，并用逗号分隔，元素类型可以不同。
创建
直接通过一对圆括号创建元组对象。
使用tuple()函数将列表、range对象、字符串或其他类型的可迭代对象转换为元组。
删除
当不再使用时，可通过del命令删除元组，删除后不可再调用
del d_tuple\nprint(d_tuple)\n\n
NameError: name 'd_tuple' is not defined
元组和列表的联系与区别
元组和列表都属于可迭代对象，支持索引和切片操作
支持重复运算（*）和合并运算（+）\n\n\n
支持一些常见的序列处理函数，例如 len()、max()、min() 等\n\n
二者之间可相互转化，可使用tuple()将列表转化为元组，list()将元组转化为列表
生成器推导式
字符串
字符串是由字符组成的一个不可变序列，和元组作用类似，也支持索引、切片、重复、合并等操作。Python中统一了“字符”和“字符串”的概念，字符串的内容放在一对引号中，可以是一对单引号、双引号或三引号。
字符串和元组的主要区别
元组的元素可以是各种各样的数据类型（整形、浮点型、字符类型等） 字符串的每个元素都是字符
字符串的创建
直接通过一对引号创建字符串对象（对于一些特殊字符可使用转义字符）
a_str="hello"\nb_str=""
使用str()函数将其他类型对象转化为字符串对象。
c_str=str()\nd_str=str(20)\ne_str=str([1,2,3])
字符表的常见方法及作用
index(子串，起点，终点)
在区域中查找子串，不存在时报错
count(子串, 起点, 终点)
统计指定区域中子串出现的次数，不存在时返回0
split(分隔符, 最多分割次数)
按照分隔符对字符串进行分割，返回结果列表
lower()、upper()
将字符串中所有字母转化为小（大）写字母，生成一个新字符串
swapcase()
转变字符串中所有字母的大小写，生成一个新字符串
replace(旧字符, 新字符, 次数)
替换字符串中的指定元素，可指定替换次数，默认替换所有
join(可迭代对象)
用字符串将可迭代对象中的多个元素拼接起来
startswith(字符串, 起点, 终点)
判断字符串的指定区域是否以指定的字符串开始，结果为True或False
endswith(字符串, 起点, 终点)
判断字符串的指定区域是否以指定的字符串结束，结果为True或False
center(宽度, 填充字符)
指定字符串显示宽度，内容居中显示，左右两边填充指定字符
strip(字符)
去除字符串前后的字符，默认去除前后空白
isdigit()
判断字符串中所有字符是否都为数字
isalpha()
判断字符串中所有字符是否都为字母，广义上的字母
isalnum()
判断字符串中所有字符是否都为数字或字母
isidentifier()
判断字符串是否为合法标识符
集合
集合的定义、创建和删除
集合的定义
列表、元组、字符串属于序列, 它们的元素都是有顺序的, 可以通过索引访问元素, 也可以支持切片操作, 元素是可以重复的。\n集合：不能存在重复元素。\n\n
集合的创建
直接通过一对大括号包裹元素创建集合对象
使用set()函数将列表、range对象、字符串或其他类型的可迭代对象转换为集合，此时会删除其中的重复元素。
集合的删除
del c_set\n
集合的常用方法
add(元素)
向集合中添加一个元素，元素为不可变类型，不能是列表、集合等可变类型，如果该元素已存在则没什么变化
update(可迭代对象)
将可迭代对象中的元素依次添加到集合中去，去除重复元素
copy()
将集合复制一份
pop()
随机删除一个元素，并返回删除的元素
a_set= {1,8,5,"A",9}\nb_set=a_set.copy()\nprint(b_set.pop())\nprint(a_set)\nprint(b_set)
输出结果
remove(元素)
从集合中删除某个元素，如果该元素不存在，则抛出错误KeyError
a_set= {1,8,5,"A",9}\nb_set=a_set.copy()\nprint(b_set.remove(8))\nprint(a_set)\nprint(b_set)
输出结果
discard(元素)
从集合中删除某个元素，如果该元素不存在，则什么都不做
a_set= {1,8,5,"A",9}\nb_set=a_set.copy()\nprint(b_set.discard(8))\nprint(b_set.discard(6))\nprint(a_set)\nprint(b_set)
输出结果
clear()
清空集合的内容
a_set= {1,8,5,"A",9}\nb_set=a_set.copy()\nb_set.clear()\nprint(a_set)\nprint(b_set)
输出结果
集合运算
交集
集合A和集合B的交集由既属于A又属于B的元素构成
集合A & 集合B\n集合A. intersection(集合B)
并集
集合A和集合B的并集由属于A或属于B的元素构成
集合A | 集合B\n集合A. union(集合B)
差集
集合A和集合B的差集由属于A但不属于B的元素构成
集合A - 集合B \n集合A. difference(集合B)
对称差集
集合A和集合B的对称差集由A和B的差集或B和A的差集组成
集合A ^ 集合B\n集合A.symmetric_difference(集合B)
子集判断
判断集合A是否为集合B的子集
集合A.issubset(集合B)\n集合A <= 集合B
父集判断
判断集合A是否为集合B的父集
集合A.issuperset(集合B)\n集合A >= 集合B
集合推导式
集合推导式写法类似于列表推导式，只是用一对大括号表示，而不是一对中括号。同时会去除结果中的重复元素。
a_set = {x*x for x in range(-5, 5)}\nb_set = {x*2 for x in ["A", "B", "A", 2, 4, 2]}\nc_set = {x*2 for x in ["A", "B", "A", 2, 4, 2] if str(x).isdigit()}\nd_set = {x for x in [2, 4, 6, 8] if x in [1, 3, 6, 4]}\n# 求交集\ne_set = {x for x in [2, 4, 6, 8] if x not in [1, 3, 6, 4]}\n# 求差集\nf_set = {x + y for x in [2, 4, 6, 8] for y in [1, 3, 5]}\n# 求并集\nprint(a_set) print(b_set) print(c_set) print(d_set) print(e_set) print(f_set)
输出结果
字典
字典的定义、创建
定义
字典是一种映射类型，由若干”键(key) : 值(value)”组成\n“键”和“值”之间用冒号隔开，所有“键值对”放在一对大括号“{ }”内，并用逗号分隔。其中“键”必须为不可变类型，在同一个字典中\n“键”必须是唯一的，但“值”可以重复。
创建
直接通过一对大括号包裹键值对创建字典对象
使用dict()函数创建字典对象
字典元素的访问
字典是无序的，因此不支持索引、切片等操作。主要通过字典对象[键]获取对应的值。此外，字典还提供了获取所有键值对、所有键、所有值的方法。
a_dict={"姓名":"张三","年龄":20,"体重":172,"身高":172}\nprint("遍历key值1：",end= " ")\nfor key in a_dict:\n print(a_dict[key],end= " ")\nprint("\\\\n遍历key值2：",end= " ")\nfor key in a_dict.keys():\n print(a_dict[key],end= " ")\nprint("\\\\n遍历value值：",end= " ")\nfor value in a_dict.values():\n print(value,end=" ")\nprint("\\\\n遍历item值：",end= " ")\nfor item in a_dict.items():\n print(item,end=" ")\nprint("\\\\n遍历键值对1：",end= " ")\nfor key,value in a_dict.items():\n print(key,":",value,end= " ")\nprint("\\\\n遍历键值对2：",end= " ")\nfor (key,value) in a_dict.items():\n print(key,":",value,end=" ")
输出结果
字典的常见方法
字典推导式
字典排序
本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 Jinnno的个人博客！
