【入门到精通】Python编程集合,一篇文章全讲解

'''部分命名规则：  1. 不得使用关键字进行命名，例如：    print.py等  2. 不得使用拼音进行命名  3. 多个单词组成的名称时，需要通过_或者开头字母大写的形式将各个单词区分开，例如：    MyFirstPython、my_first_python  4. 命名时要统一命名格式，尽量保持同一种风格的命名方式，便于阅读者快速理解  5. 名称前添加_表示私有，名称后添加_表示避免关键字'''

# 单个#放在行头，表示整行注释，一般用于对下方的单行或者几行代码进行讲解print('黄财财') # 代码结尾的# 表示从当前位置开始注释，一般是通过注释的形式对本行代码进行讲解'''  通过这种格式实现多行注释，一般用于对整个文件、一个完整代码块等进行注释讲解'''

# 语法格式：变量名 赋值符号 变量值name = '黄财财' # '='表示将'黄财财'赋值给到'name'变量。而不是说'name'变量等于'黄财财'# 同时为多个变量进行赋值# 变量a/b/c都赋值为'黄财财'a = b = c = '黄财财'# 变量a赋值为1，b赋值为2，c赋值为3a, b, c = 1, 2, 3

'''1. 在内存中申请一块空间，用来存储'黄财财'2. 将'黄财财'所在的内存空间地址，绑定给到name变量3. 如果要访问'黄财财'，则直接通过name变量访问即可'''name = '黄财财'print(name)# 如果此时将另外一个内存地址绑定给到name变量，则原本的'黄财财'被pass掉，最后输出新的值name = '变量值'print(name)'''综上所述：1. 变量通过赋值，来进行数据的存储2. 调用变量，实质意义上就是调用变量所指向的内存地址中的值3. 一个变量在同一时间内只能指向一个值，如果对其进行多次赋值，则保留最后一次的赋值内容拓展：多个变量可以指向同一个内存地址，也就是多个变量可以赋值同一个内存空间的值。'''name = name1 = '黄财财'print(id(name), id(name1))# 输出结果 id(name) = 8553264 , id(name1) = 8553264，两个地址相同

'''  在python中，所有的数字都属于Number类型，不管是int、float、bool，还是complex    bool类型只有True和False两个值，在Number中，True表示1，False表示0    complex类型，我个人很少用到，以后如果有用到再具体说明吧。'''a, b, c, d = 10, 1.1, True, 4 + 3jprint(type(a), type(b), type(c), type(d))# 输出结果：<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

'''  在python中，字符串用单引号''或者双引号""括起来，如果遇到特殊字符，则通过反斜杠\进行转义。  \是转义字符，将特殊字符以原文进行输出。避免因为特殊符号导致原文解析出现问题。'''str1 = '单引号字符串'print(str1)str2 = "双引号字符串"print(str2)str3 = '这是带\'单引号\'的字符串' # 字符串的内容包含有单引号，但是单引号本身是特殊字符，所以用\将字符串中的单引号转义为普通字符print(str3)str4 = '这是带"双引号"的字符串' # 因为str4是用单引号括起来的，所以内部的引号用双引号，这样两者就不会冲突，双引号可以正常输出print(str4)str5 = r'这是带有\的字符串' # 如果遇到带有\的字符串，可以在字符串前加上r，表示为原文输出，这样也可以实现转义

'''  在Python中，列表是用中括号[]括起来，用以实现大多数集合类的数据结构。  列表中的内容都是以元素来定义，一个列表可以包含多个元素，元素可以是不同的数据类型，不同元素间用逗号,进行分隔  获取列表中的元素内容时，通过下标来获取，下标的计算是从0开始的，所以说，如果列表有10个元素，则最大下标值为9。    通过在列表变量名称后添加中括号，在中括号中写入下标值来获取该列表中对应的元素：      el = li1[0]    需要注意，如果列表本身下标最大为9，如果获取元素时填入了下标10，则代码运行会抛出异常IndexError: list index out of range，表示下标越界'''# 创建一个空列表li = list()  # print(li)的结果：[]  这表示li是个空的列表# 创建一个有值列表li1 = [123, '黄财财', 1.1]  # print(li1)的结果：[123,'黄财财',1.1]# 获取列表中的第一个元素el = li1[0]  # print(el)的结果： 123 这表示成功获取到第一个元素

'''    在Python中，元组类型tuple与列表类型list在使用上是相似的，都是基于下标操作元素，一个元组中可以包含各种不同类型的元素。    tuple类型是基于圆括号()将元素进行包裹。下标也是从0开始取。    元组的元素获取与列表一样，如果下标超过最大值，同样会抛出异常IndexError: tuple index out of range'''# 创建一个空元组tu = tuple()# 创建一个有值元组tu1 = (123, '黄财财', 1.1)# 获取元组中指定下标元素el = tu1[1]print(el)  # print结果：黄财财el1 = tu1[4]  # 抛出异常IndexError: tuple index out of range

'''    在Python中，集合类型set，与数学中的集合是一个概念。用来保存不重复的元素，也就意味着一个集合中，所有的元素都是唯一的，互不相同。    set类型是基于大括号{}将元素进行包裹，不同元素间用逗号进行分隔，集合内的元素是无序的。'''# 创建一个有值的集合se = {1, 2, 'a', 'c', '黄财财'}print(se)  # 实际输出执行三次，结果分别为：{1, 2, '黄财财', 'a', 'c'}，{1, 2, 'c', 'a', '黄财财'}，{1, 2, 'a', '黄财财', 'c'}# 通过set函数创建集合se1 = set("我是黄财财")print(se1)  # 实际输出结果：{'黄', '我', '财', '是'}

'''    在Python中，字典类型dictionary，在python3.5版本之后，都是有序保存的，具备有键值对形态的一种集合。同一个字典中，所有的键都是唯一的。    dict类型与set类型一样，都是基于大括号{}将每一组键值对进行包裹，不同组别间使用逗号进行分隔，获取字典内的指定键值对，都是基于键来获取。'''# 创建一个空字典di = dict()print(di)  # 实际输出结果：{}# 创建一个有值字典di1 = {    "name": "黄财财",    "age": 18,    "sexual": "male"}print(di1)  # 实际输出结果：{'name': '黄财财', 'age': 18, 'sexual': 'male'}# 基于字典的键（key）来获取对应的值（value）print(di1['name'])  # 实际输出结果：黄财财

# + 运算符a = 1b = 2c = a + b  # 对象a与对象b相加，即 1 + 2，c的结果为3d = 3 + 4  # 数字3与数字4相加，d的结果为4e = '黄' + '财财'  # 两个字符串相加，表示拼接的意思，及'黄'与'财财'进行拼接，e的结果为'黄财财'f = [1, 2] + ['黄', '财财']  # 两个集合相加，最终会组合成一个新的集合，f的结果为[1, 2, '黄', '财财']print(c, d, e, f)  # 实际输出结果：3  7  '黄财财' [1, 2, '黄', '财财']

# - 运算符c = 1 - 2print(c)    # 实际输出结果：-1

# * 运算法c = 3 * 3d = '黄财财' * 5  # 重复'黄财财'字符串5次print(c, d)  # 实际输出结果：9 黄财财黄财财黄财财黄财财黄财财

# / 运算符c = 1 / 3d = 6 / 2print(c, d)  # 实际输出结果：0.3333333333333333    3.0e = 3 / 0  # 因为除数不能为0，所以会报错：ZeroDivisionError: division by zero

# % 运算符，返回除法中的余数，没有余数则返回0c = 10 % 4d = 6 % 2print(c, d)  # 实际输出结果：2  0# ** 运算符，返回x的y次幂c = 10 ** 2  # 表示为10 * 10print(c)  # 实际输出结果：100# // 运算符，除法返回商的整数部分（向下取整）c = 9 // 2  # 实际结果为4...1，向下取整，结果为4d = -9 // 2  # 实际结果为-4...-1，向下取整，结果为-5print(c, d)  # 实际输出结果：4 -5

'''  Python 比较运算符代码示例，比较运算只有正确和失败两个结果，所以返回值为True和False  整体内容与基本的数学概念差别不大，所以一起展示'''# == 运算符，需要注意，一个=表示赋值，两个=表示对比print('黄财财' == '黄财')  # Falseprint('黄财财' == '黄财财')  # True# != 运算符print('黄财财' != '黄财财')  # Falseprint('黄财财' != '黄财')  # True# <,<=运算符print(1 <= 2)   # Trueprint(2 < 1)    # False# >,>=运算符print(1 >= 2)   # Falseprint(2 > 1)    # True

  '''  Python中的赋值运算符，主要列举最常应用的内容如=、+=、-+  其余内容只是简单介绍，不做过多讲解  '''  # = 运算符：仅能够进行赋值操作，将右边的值赋值给到左边的对象。已做过讲解  # a = 1  # b = 1 + 2  # += 运算符：加法赋值运算符  a = 1  print(a)  # 实际输出结果：1  a += 2  # 等同于 a = a + 2  print(a)  # 实际输出结果：3  # -= 运算符：减法赋值运算符，与加法赋值运算符相同  a = 2  print(a)  # 实际输出结果：2  a -= 1  # 等同于 a = a - 1  print(a)  # 实际输出结果：1  # 也有 *=、/=、%=、**=、//=这一类的赋值运算符，与前面描述的加法或减法运算符是一样的。

  '''  Python中的逻辑运算符，主要用于做条件判断，具体有三种不同的逻辑  所有逻辑判断都只有两个结果，成立（返回True），不成立（返回False）      1. and：表示与，表达式示例：x and y，x与y之间，任意一个为False，则返回False      2. or：表示或，表达式示例：x or y，x与y之间，任意一个为True，则返回True      3. not：表示非，表达式示例：not x，不为x，则返回True  '''  # 三类逻辑运算示例  print(True and False)  # 实际输出：False  print(True or False)  # 实际输出：True  print(not True)  # 实际输出：False  '''      三类逻辑运算进阶:          1. and: 若x,y都为True时，x and y会返回y的值          2. or：若x为True时，x or y会返回x的值  '''  # a = False  a = 1  # b = False  b = 2  # and  print(a and b)  # a为False，则实际输出：False，a为1，则实际输出：2  # or  print(a or b)   # a为False，则实际输出：2，a为1，则实际输出：1  # not  print(not b)    # b为False，则实际输出：True，b为True，则实际输出：False

  '''  Python中的成员运算符，用来识别成员是否在或不在指定的内容之中      1. in：表达式 x in y，如果x在y之中，则返回True，否则返回False      2. not in：表达式 x not in y，如果x不在y之中，则返回True，否则返回False  '''  a = '黄财财'  b = '黄'  c = 'caicai'  # in  print(b in a)  # 因为'黄'在'黄财财'之中，所以实际输出结果为True  print(c in a)  # 因为'caicai'不在'黄财财'之中，所以实际输出结果为False  # not in  print(c not in a)  # 因为'caicai'不在'黄财财'之中，所以实际输出结果为True  print(b not in a)  # 因为'黄'在'黄财财'之中，所以实际输出结果为False

  '''      Python中每个对象都有属于自己的id值，查看id值的方法为id()      身份运算符就是判断对象的id值是否一致。      身份运算符：          同身份运算符is              当两个变量指向的是同一个对象，则返回为True，否则返回为False          非同身份运算符is not              当两个变量指向的是同一个对象，则返回False，否则返回为True  '''  # 定义基本的变量  a = 1  b = 2  c = a  print(id(a))  print(id(b))  print(id(c))  print(a is c)  # True  print(a is not b)  # True  # 对于数值与字符对象，相同的值通常身份也相同，但列表相同，身份通常是独立的  l = []  s = []  print(l is s)  # False  print(l is not s)  # True

string1 = 'hello word'string2 = 'huang cai cai'# 截取单个字符串的值print(string1[0])# 截取多个字符串的值print(string2[1:5])

string1 = 'huang cai cai'# 字符串与字符串之间的连接，通过+进行print(string1 + 'Python')

# 1. 通过切换单双引号对包含有引号的内容进行处理string1 = '"Hello World" ——世界上最伟大的代码'    string2 = "'Python是最好的编程语言'——黄财财说的"print(stirng1)print(string2)# 2. 转义字符\对特殊字符进行处理，加上\的引号将作为字符串进行输出string3 = '鲁迅先生说：\'世上本无路，走的人多了自然就有路了。\''print(string3)# 3. 对转义字符\进行处理，在转义字符\前，再加一个\，则可以将\作为字符串进行输出string4 = 'C:\\Users\\HuangCaicai\\chrome.exe'print(string4)

string1 = 'Huangcaicai'string2 = 'Dota2'# 在原有字符串中，进行格式化输出，将定义的变量传入字符串内容。print('我是{0}，我最喜欢打的游戏叫做{1}'.format(string1,string2))# 也可以直接使用字符串进行传入print('这里是{}带来的Python教学。'.format('黄财财'))

# 三引号字符串使用string1 = '''<html>    <header></header>    <body>        <input type="text" id="AutoTest" name="huangcaicai"/>    </body></html>'''# 输出内容可以将所有的特殊字符正常输出，再也不用再为各类特殊字符费神啦~print(string1)

# 定义一个普通字符串string1 = 'Huangcaica Python Class'# 将string1 转换编码为gbkstring2 = string1.encode(encoding='gbk')print(string2)# 将string2 以gbk编码格式进行解码print(string2.decode(encoding='gbk'))

string1 = 'HuangCaiCai Python Class'# 将string1中的内容全部转换为大写string2 = string1.upper()print(string2)# 将已经全部转换为大写的string2中的内容全部转换为小写string3 = string2.lower()print(string3)

# 定义一个包含空格的字符串内容string = '    黄财财真的   是在教Python    'print(string)# 去除字符串开头的空格内容print(string.lstrip())# 去除字符串结尾的空格内容print(string.rstrip())# 去除字符串中首尾的空格内容print(string.strip())# 去除字符串中所有的空格内容print(string.replace(' ', ''))

# 定义一个字符串string = '000000000who 00are you0000!'# 将字符串中所有的0替换为空值print(string.replace('0', ''))# 将字符串中的0替换为xprint(string.replace('0', 'x'))# 将字符串中的0替换为空值，只替换5次print(string.replace('0', '', 5))

# 定义一个字符串string = '00000huang0000caicai0000'# 通过strip函数去除string中首尾存在的0print(string.strip('0'))

# 定义一个字符串string = 'this is huangcaicai'# 通过find查找字符串中是否包含huangcaicai，存在，则返回开始的索引值print(string.find('huangcaicai'))# 通过find查找字符串中是否存在黄财财，不存在，则返回-1print(string.find('黄财财'))

# 定义一个字符串string = 'this is huangcaicai'# split函数调用，分割后会以list格式返回结果# 不传入参数，会基于空格进行分割print(string.split())# 设置基于i进行分割，不设置分割次数print(string.split('i'))# 设置基于i进行分割，设置只分割一次print(string.split('i', 1))

# 通过逗号将list中的元素进行分割，拼接为一个新的字符串print(",".join(['a', 'b', 'c']))# 通过join函数将list中的内容拼接为一个新的字符串print("".join(['a', 'b', 'c']))

# 声明有值的listli = ['huangcaicai', 'python', 8888, 123456]# 声明无值的listli = list()

# 创建一个list列表li = ['huangcaicai', 'python', 8888, 123456]# 获取指定下标的元素print(li[0])# 获取多个下标的元素print(li[0:3])# 获取list中倒数第二个值print(li[-2])# 获取list中从第二个到最后一个值print(li[1:])# 获取list中从第一个到倒数第二个值print(li[:-1])

# 创建一个list列表li = ['huangcaicai', 'python', 8888, 123456]# 对li进行元素的添加li.append('zxc')li.append(22222)print(li)

# 创建一个list列表li = ['huangcaicai', 'python', 8888, 123456]# 对li的指定元素进行修改li[1] = 'Python'print(li)

# 创建一个list列表li = ['huangcaicai', 'python', 8888, 123456]# 通过del关键字对li进行元素的删除del li[1]   # del关键字删除是基于元素下标，将指定的下标元素进行删除print(li)# 通过remove()函数对li进行元素的删除li.remove(8888) # remove()函数删除是基于元素值，将首个匹配的元素进行删除，只执行一次print(li)

# 创建一个list列表li = ['huangcaicai', 'python', 8888, 123456]# 获取当前list的长度print(len(li))

# 创建三个list列表li1 = ['huangcaicai', 'python', 8888, 123456]li2 = [3, 2, 123, 654]li3 = ['是', '黄财财', 'asdas']# 对统一为int类型的li2进行排序li2.sort()print(li2)print(sorted(li2))# 对统一为string类型的li3进行排序li3.sort()print(sorted(li3))# 对数据类型不统一的li1进行排序li1.sort()print(li1)  # 结果会报错print(sorted(li1))  # 结果会报错

'''    list中提供有extend()函数来实现将新的list添加到现有的list中，但只支持两个list合并    如果有两个以上list需要合并，其实直接通过+来合并会更加简单。    不过需要注意，list默认是不会将重复元素去除的。如果需要实现去重，需要用到其他技术'''# 创建三个list列表li1 = ['huangcaicai', 'python', 8888, 123456]li2 = [3, 2, 123, 654]li3 = ['是', '黄财财', 'asdas']# 通过+合并多个listli4 = li1 + li2 + li3print(li4)# 通过extend()函数实现两个list的合并li1.extend(li2)print(li1)

# 创建list列表li1 = ['huangcaicai', 'python', 8888, 123456]# 反向list中的元素，重新进行排序li1.reverse()print(li1)

# 使用set()创建空集合set1 = set()print(set1)# 使用set()创建有值集合set2 = set(('a', 'b', 'c', 'd'))print(set2)# 使用{}创建有值集合set3 = {1, 2, 3, 4, 5, 6}print(set3)# 集合默认去重set4 = {1, 2, 3, 4, 5, 4, 3, 2, 1}print(set4)

# 使用set()创建空集合set1 = set()# 添加元素进入到set1中set1.add('sss')print(set1)

# 使用{}创建有值集合set3 = {'a', 'b', 'c', 'd', 'e', 'f'}# discard()删除指定元素set3.discard('c')print(set3)# pop()删除随机元素set3.pop()print(set3)# clear()清空所有元素set3.clear()print(set3)

# 使用{}创建有值集合set3 = {'a', 'b', 'c', 'd', 'e', 'f'}# in判断指定内容是否是集合中的元素print('a' in set3)  # 存在返回Trueprint(1 in set3)  # 不存在返回False

# 创建有值集合set1 = set(('a', 1, 3, 'd'))set2 = {1, 2, 3, 4, 5, 6}set3 = {1, 2, 3, 4, 5, 4, 3, 2, 1}# 判断两个集合间的交集print(set1.intersection(set2))# 判断多个集合间的交集，多个集合传入通过逗号区分print(set3.intersection(set1, set2))

# 创建有值集合set1 = set(('a', 1, 3, 'd'))set2 = {1, 2, 3, 4, 5, 6}# 判断两个集合间的差集，生成新的集合set3 = set1.difference(set2)print(set3)# difference_update()函数的使用示例# set1.difference_update(set2)# print(set1)set2.difference_update(set1)print(set2)

# 创建一个空字典di1 = dict()di2 = {}print(di1)print(di2)# 创建一个有值字典，key不可重复，不同键值对之间通过逗号分隔di3 = {    'name': '黄财财',    'age': 18,    'sexual': 'male'}print(di3)

# 创建一个有值字典，key不可重复，不同键值对之间通过逗号分隔di1 = {    'name': '黄财财',    'age': 18,    'sexual': 'male'}print(di1['name'])  # 获取di1中name对应的value值print(di1['age'])  # 获取di1中age对应的value值print(di1['sexual'])  # 获取di1中sexual对应的value值

# 创建一个有值字典，key不可重复，不同键值对之间通过逗号分隔di1 = {    'name': '黄财财',    'age': 18,    'sexual': 'male'}# 新增键值对di1['school'] = '黄财财专属课堂'print(di1)# 修改已有键值对di1['age'] = 28print(di1)

# 创建一个有值字典，key不可重复，不同键值对之间通过逗号分隔di1 = {    'name': '黄财财',    'age': 18,    'sexual': 'male'}# 删除指定键值对del di1['age']print(di1)# 清空整个字典内容di1.clear()print(di1) 

# 创建一个有值字典，key不可重复，不同键值对之间通过逗号分隔di1 = {    'name': '黄财财',    'age': 18,    'sexual': 'male'}# items()获取字典中的每一组键值对print(di1.items())# keys()获取字典中的所有keyprint(di1.keys())# values()获取字典中所有的valueprint(di1.values())

# 创建一个有值元组tuple1 = (1, 2, 3, 4, 5)print(tuple1)# 创建一个空值元组tuple2 = ()print(tuple2)# 元组中若只有一个值，需要添加逗号，不然()会被识别为运算符tuple3 = (1)print(type(tuple3))  # 显示tuple3为int类型tuple4 = (11,)  # 如果创建一个元素的元组，则需要在元素后方添加逗号print(type(tuple4))  # 显示tuple4为tuple类型

# 创建一个有值元组tuple1 = (1, 2, 3, 4, 5)# 获取元组中指定单个元素print(tuple1[0])# 获取元组中多个元素print(tuple1[1:4])

# 创建一个有值元组tuple1 = (1, 2, 3, 4, 5)# 在原有元组上进行元素值的修改# tuple1[0] = 'aaa'   # 会报错，因为元组无法被修改# 删除元组中的元素# del tuple1[0]   # 会报错，因为元组不支持元素的删除。# 删除整个元组# del tuple1  # 可以正常删除整个元组。# 创建新的元组，增加新的值tuple2 = ('a',) + tuple1print(tuple2)

'''    If基本语法结构说明：        if 条件：            if语句块        else 条件：            else语句块    当条件满足if时，进入if语句块代码执行，当条件不满足if时，进入else语句块执行。    一个判断只会执行一次，要么if，要么else。'''a = True# if判断。if a is True:    print('这里是if语句块')  # 如果a为True，则进入此部分else:    print('这里是else语句块')  # 如果a不为True，则进入此部分'''    if进阶：elif语法        if 条件1:            if语句块        elif 条件2:            elif语句块        elif 条件3:            elif语句块        else:            else语句块    if...elif...else语法结构，也只会执行一次，如果满足if判断，则执行if语句块，其余    内容不再执行，若不满足if，则判断elif，若都不满足，则进入else。'''a = Trueb = Falseif a is True:    print('这里是a代码块')elif b is False:    print('这里是b语句块')else:    print('这里是else语句块')'''    if语句单条件语法：        if 条件:            if语句块    在if语法结构中，if可以单独使用，也可以关联elif使用，else不是必须项。    若判断条件都不满足，则不会进入if之中。'''a = Trueb = False# 不添加else的if判断写法if a is False:    print('这是a语句块')elif b is False:    print('这是b语句块')'''    pass关键字，在if判断语法中，用于表示略过。    一般在判断过程中，如果不需要执行额外代码的情况下，可以调用pass实现。'''a = Trueif a is True:    passelse:    print('这是else语句块')

'''    For循环语法结构：        for 条件：            循环块'''li = [1, 2, 3, 4, 5, 6, 7]# 循环读取list中的所有元素for i in li:    print(i)'''    内置函数range()的使用:        range函数可以创建一个临时的整数列表。一般用在for循环中。        range(start, stop[, step])中，start是开始计数，stop是停止，step是步长        range(0,5)生成[0,1,2,3,4]        range(0,5,2)生成[0,2,4]'''# 基于range()实现的循环for i in range(0, 5):    print(i)for i in range(0, 5, 2):    print(i)'''    break与continue关键字用法：        在循环中，可以通过break退出整个循环；或者通过continue退出本次循环。'''# break用法：当i为3时，整个for循环全部结束，后续的循环不再执行for i in range(0, 5):    if i == 3:        break    print(i)# continue用法：当i为3时，本次循环结束，continue后面的代码不再执行，进入新的一轮循环。for i in range(0, 5):    if i == 3:        continue    print(i)

'''    While循环语法结构：        while 判断条件:            while循环体    使用while时，需要避免死循环。导致程序无法正常执行。        死循环：一直在循环体中，无限执行循环，无法跳出循环。    while循环也支持break跳出循环，continue跳出本次循环。'''# while示例：基于a的增长，循环判断a<10的条件是否成立，如果成立则持续运行循环，直到不满足为止。a = 1while a < 10:    print(a)    a += 1    if a == 3:        continue# 死循环示例：因为True条件一直成立，所以会在循环中无法结束，从而导致死循环。# while True:#     print(a)#     a += 1# 为避免出现死循环，所以在while循环时，考虑判断条件的设定，以及通过设置break来处理while True:    print(a)    a += 1    if a == 20:        break  # 满足判断则结束循环