Python上-CSDN博客

本文链接：https://blog.csdn.net/daimabanyun/article/details/138531340

虚拟环境搭建

创project项目时自己选
为存在的project创建 file->settings->项目名->python interpreter->右侧齿轮add创建

运行方式

注释

单行注释行前加#

多行注释在""" """或''' '''

快捷键： ==ctrl + /==

变量

变量就是一个存储数据的的时候当前数据所在的内存地址的名字而已。

标识符

标识符命名规则是Python中定义各种名字的时候的统一规范，具体如下：

由数字、字母、下划线组成
不能数字开头
不能使用内置关键字
严格区分大小写

关键字：

Python的33个保留字如下：False、None、True、and、as、assert、break、class、continue、def、del、elif、else、except、finally、for、from、global、if、import、in、is、lambda、nonlocal、not、or、pass、raise、return、try、while、with、yield。

命名习惯

见名知义。
大驼峰：即每个单词首字母都大写，例如：MyName。
小驼峰：第二个（含）以后的单词首字母大写，例如：myName。
下划线：例如：my_name。

常量Python没有常量行业内默认全大写为常量但可以修改

数据类型

number（int，float） a = 1 print(type(a)) # <class 'int'> -- 整型 b = 1.1 print(type(b)) # <class 'float'> -- 浮点型 c = True print(type(c)) # <class 'bool'> -- 布尔型 d = '12345' "显示单行" """显示多行""" '''显示多行''' print(type(d)) # <class 'str'> -- 字符串 e = [10, 20, 30] # 可以放任意类型内容逗号隔开 print(type(e)) # <class 'list'> -- 列表 f = (10, 20, 30) #可以放任意类型内容逗号隔开 print(type(f)) # <class 'tuple'> -- 元组 h = {10, 20, 30} #可以放任意不可变数据类型内容逗号隔开自动去重 print(type(h)) # <class 'set'> -- 集合 g = {'name': 'TOM', 'age': 20} #key:value键值对形式key整体必须是不可变数据类型 print(type(g)) # <class 'dict'> -- 字典

可变数据类型:list、dict、set内存中的数据可以被修改（可以通过变量名调用方法来修改列表和字典内部的内容，而内存地址不发生变化）

不可变数据类型:number (int、 float) 、string、tuple内存中的数据不允许被修改（一旦被定义，内存中分配了小格子，就不能再修改内容了）内容值改变，内存数据地址也变

真=true、1，假=false、0

输出

作用：程序输出内容给用户

print('hello Python')

转义字符

\n：换行。 \t：制表符，一个tab键（4个空格）的距离。 R：取消转义 s1 = R"你好，\n我叫\t张三，今年18岁" print(s1)#你好，\n我叫\t张三，今年18岁

结束符

print('输出的内容', end="\n")

在Python中，print()，默认自带end="\n"这个换行结束符，所以导致每两个print直接会换行展示，用户可以按需求更改结束符。end=""不换行

输入

input("提示信息"),在Python中，程序接收用户输入的数据的功能即是输入。

输入的特点

当程序执行到input，等待用户输入，输入完成之后才继续向下执行。
在Python中，input接收用户输入后，一般存储到变量，方便使用。
在Python中，input会把接收到的任意用户输入的数据都当做字符串处理。

占位符号

a= input("请输入姓名:") b= input("请输入年龄:") print("用户姓名:%s，今年,%s岁"%(a, b))

a ="张三" b= 18 print("用户姓名:{}，今年:{}岁".format(b, a)) print("用户姓名:{name}，今年:{age}岁".format(age=b,name=a)) print("用户姓名:{0}，今年:{1}岁{0}".format(a,b))

print(f"用户姓名:{a}，今年:{b}岁")

运算符

算数运算符

赋值运算符

复合赋值运算符

比较运算符

逻辑运算符

is a is b 判断a，b内存地址相等相等返回true不相等返回false

is not a is not b 判断a，b内存地址不相等不相等返回true相等返回false

数据类型转换

int(x[,base])#将x转换为一个整数 float(x)#将x转换为一个浮点数 complex(real [,imag])#创建一个复数,real为实部,imag为虚部 str(x)#将对象x转换为字符串 repr(x)#将对象x转换为表达式字符串 eval(str)#用来计算在字符串中的有效Python表达式,并返回一个对象 tuple(s)#将序列s转换为一个元组 list(s)#将序列s转换为一个列表 chr(x)#将一个整数转换为一个Unicode字符 ord(x)#将一个字符转换为它的ASCII整数值 hex(x)#将一个整数转换为一个十六进制字符串 oct(x)#将一个整数转换为一个八进制字符串 bin(x)#将一个整数转换为一个二进制字符串 bool(x)#将x转换为布尔型除了0和空内容其他均为true

字符串

字符串是 Python 中最常用的数据类型。我们一般使用引号来创建字符串。创建字符串很简单，只要为变量分配一个值即可。

a = 'hello world' b = "abcdefg" print(type(a))#<class 'str'> print(type(b))#<class 'str'>

注意：控制台显示结果为<class 'str'>，即数据类型为str(字符串)。

字符串输出

print('hello world')#hello world name = 'Tom' print('我的名字是%s' % name)#我的名字是Tom print(f'我的名字是{name}')#我的名字是Tom

字符串输入

在Python中，使用input()接收用户输入。

代码

name = input('请输入您的名字：') print(f'您输入的名字是{name}') print(type(name)) password = input('请输入您的密码：') print(f'您输入的密码是{password}') print(type(password))

字符串运算符

in判断在字符串里面，not in判断不在字符串里面

字符串方法

（1）方法upper（）：将小写字母化为大写字母。

（2）方法lower（）：将大写字母化为小写字母。

（3）方法title（）：所有单词的首字母是大写，其余均为小写

（4）方法capitalize（）：将字符串的第一个字符转换为大写。

（5）方法swapcase（）：将字符串中大写转换成小写，小写转换成大写。

str1 = 'I love Python' str2 = str1.upper() str3 = str1.lower() str4 = str1.title() str5 = str1.capitalize() str6 = str1.swapcase() print(str2,str3,str4,str5,str6,sep = '\n')

isalnum() 如果字符串中至少有一个字符并且所有字符都是字母或数字，则返回True，否则返回 False。

s = 'python' print(s.isalnum())#True s = '123' print(s.isalnum())#True s = 'python123' print(s.isalnum())#True s = 'python-123' print(s.isalnum())#False

isalpha()

如果字符串中至少有一个字符并且所有字符都是字母或中文，则返回True，否则返回 False。

isnumeric()

如果字符串中至少有一个字符并且所有字符都是数字，则返回True，否则返回 False。

find()

检测指定内容是否包含在字符串中，如果是返回开始的索引值，否则返回-1（index没有直接报错）

s = 'Machine Learning' idx = s.find('a') print(idx)#1 print(s[idx:])# achine Learning s = 'Machine Learning' idx = s.find('aa') print(idx)#-1 print(s[idx:])# g #此外，还可以指定开始的范围。 s = 'Machine Learning' idx = s.find('a', 2) print(idx)#10 print(s[idx:])#arning

join（）

函数拼接：sep.join（iterable）

释：以sep作为分隔符，将iterable中所有的元素合并为一个新的字符串。

list_val = ['www','baidu','com'] str_val = '.'.join(list_val) print(str_val) tuple = ('User','andy','code') str_val = '/'.join(tuple) print(str_val)

split（）

通过指定分割符对字符串进行切片，拆分字符串。（在没有指定分割符时默认空白字符串切片，切割后是个列表）

str.split（"分割符",分割次数)

strip（）

移除字符串头尾指定的字符（默认为空白或换行符）或字符序列。

str.strip（[chars]） chars：移除字符串头尾指定的字符序列

注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。

str = " Love Python\n\t\r "

print(str.strip())

startswith（）

查询字符串是否以指定子字符串开头

str.startswith（“被检索的字符串”，检索的起始位置，检索的结束位置）

注意：如果找到了返回True，否则返回False。

str = "LoveYouPython" print(str.startswith("L")) print(str.startswith("o"))

endswith（）

查询字符串是否以指定子字符串结尾

str.endswith（“被检索的字符串”，检索的起始位置，检索的结束位置）

注意：如果找到了返回True，否则返回False。

str = "LoveYouPython" print(str.endswith("n")) print(str.endswith("o"))

count()

返回某个子串在字符串中出现的次数

注意：count()和find()、index()语法一致，只是结果返回子串出现次数

len()

返回字符串的长度

len(字符串序列)

replace()

用新子串替换旧子串

字符串序列.replace(旧⼦串, 新⼦串, 替换次数)

mystr = "hello world and you and Python" print(mystr.replace('and', '&'))#结果：hello world & you & Python，省略第三个参数默认替换所有子串 print(mystr.replace('and', '&', 10))#结果： hello world & you & Python，第三个参数大于子串个数默认替换所有子串 print(mystr)#结果： hello world and you and Python【未改变原字符串】

优先级

切片

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

语法

序列[开始位置下标:结束位置下标:步长]

注意

不包含结束位置下标对应的数据，正负整数均可；

步长是选取间隔，正负整数均可，默认步长为1。print(name[2:7:2]) # ceg从2取到7间隔2个取一次

体验

name = "abcdefg" print(name[2:5:1]) # cde print(name[2:5]) # cde print(name[:5]) # abcde print(name[1:]) # bcdefg print(name[:]) # abcdefg print(name[::2]) # aceg print(name[:-1]) # abcdef, 负1表示倒数第一个数据 print(name[-4:-1]) # def print(name[::-1]) # gfedcba

元组

定义

元组使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型，一个元组可以存储多个数据，元组内的数据是不能修改的，死数据

创建

多个数据元组 t1 = (10, 20, 30) 单个数据元组 t2 = (10,) print(type(t2)) # tuple t3 = (20) print(type(t3)) # int

注意：如果定义的元组只有⼀个数据，那么这个数据后面也要添加逗号，否则数据类型为唯⼀的这个数据的数据类型

操作

元组数据不支持修改，只支持查找

下标查找数据

tuple1 = ('aa', 'bb', 'cc', 'bb') print(tuple1[0]) # aa

index()

查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index方法相同。

tuple1 = ('aa', 'bb', 'cc', 'bb' print(tuple1.index('aa')) # 0

count()

统计某个数据在当前元组出现的次数。

tuple1 = ('aa', 'bb', 'cc', 'bb') print(tuple1.count('bb')) # 2

len()

统计元组中数据的个数。

tuple1 = ('aa', 'bb', 'cc', 'bb') print(len(tuple1)) # 4 #注意：元组内的直接数据如果修改则立即报错 tuple1 = ('aa', 'bb', 'cc', 'bb') tuple1[0] = 'aaa'#报错

in not in + *

tuple1 = ('aa', 'bb', 'cc', 'bb') tuple2 = ('ee', 'dd') print(tuple1+tuple2） # ('aa', 'bb', 'cc', 'bb','ee', 'dd') print(tuple1*2)#('aa', 'bb', 'cc', 'bb','aa', 'bb', 'cc', 'bb') #但是如果元组里面有列表，修改列表里面的数据则是支持的，故自觉很重要。 tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30) print(tuple2[2]) # ['aa', 'bb', 'cc']访问到列表 tuple2[2][0] = 'aaaaa'#[]嵌套 print(tuple2)# 结果：(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)

注意：元组的访问和处理速度比列表要快

删除元组元组中的元素值是不允许删除的，可以使用del语句来删除整个元组。

tup = ('一', '二', '三', '四','五') print (tup)#('一', '二', '三', '四','五') del tup print ("删除后的元组 tup : ") print (tup)#以上实例元组被删除后，输出变量会有异常信息.

列表

列表的格式

[数据1, 数据2, 数据3, 数据4......]

列表可以一次性存储多个数据，且可以为不同数据类型。

列表的常用操作

列表的作用是一次性存储多个数据，可以对这些数据进行的操作有：增、删、改、查。

查找

下标

name_list = ['Tom', 'Lily', 'Rose'] print(name_list[0]) # Tom print(name_list[1]) # Lily print(name_list[2]) # Rose

函数

index()：返回指定数据所在位置的下标。

语法

列表序列.index(数据, 开始位置下标, 结束位置下标)

快速体验

name_list = ['Tom', 'Lily', 'Rose'] print(name_list.index('Lily', 0, 2)) # 1 注意：如果查找的数据不存在则报错。

count()：统计指定数据在当前列表中出现的次数。

name_list = ['Tom', 'Lily', 'Rose'] print(name_list.count('Lily')) # 1

len()：访问列表长度，即列表中数据的个数。

name_list = ['Tom', 'Lily', 'Rose'] print(len(name_list)) # 3

判断是否存在

in：判断指定数据在某个列表序列，如果在返回True，否则返回False

name_list = ['Tom', 'Lily', 'Rose'] print('Lily' in name_list)#True print('Lilys' in name_list)#False

not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False

name_list = ['Tom', 'Lily', 'Rose'] print('Lily' not in name_list)#False print('Lilys' not in name_list)#True

体验案例需求：查找用户输入的名字是否已经存在。

name_list = ['Tom', 'Lily', 'Rose'] name = input('请输入您要搜索的名字：') if name in name_list: print(f'您输入的名字是{name}, 名字已经存在') else: print(f'您输入的名字是{name}, 名字不存在')

增加

作用：增加指定数据到列表中。

append()

列表结尾追加数据。

语法

列表序列.append(数据)

name_list = ['Tom', 'Lily', 'Rose'] name_list.append('xiaoming') print(name_list)#['Tom', 'Lily', 'Rose', 'xiaoming']

列表追加数据的时候，直接在原列表里面追加了指定数据，即修改了原列表，故列表为可变类型数据。注意如果append()追加的数据是一个序列，则追加整个序列到列表

name_list = ['Tom', 'Lily', 'Rose'] name_list.append(['xiaoming', 'xiaohong']) print(name_list)#['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]

extend()

列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表。

语法

列表序列.extend(数据)

单个数据 name_list = ['Tom', 'Lily', 'Rose'] name_list.extend('xiaoming') print(name_list)#['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g'] 序列数据 name_list = ['Tom', 'Lily', 'Rose'] name_list.extend(['xiaoming', 'xiaohong']) print(name_list)#['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']

insert()

指定位置新增数据。

语法

列表序列.insert(位置下标, 数据)

name_list = ['Tom', 'Lily', 'Rose'] name_list.insert(1, 'xiaoming') print(name_list)#['Tom', 'xiaoming', 'Lily', 'Rose']

删除del

语法

del 目标

快速体验

删除列表 name_list = ['Tom', 'Lily', 'Rose'] del name_list print(name_list)#报错提示：name 'name_list' is not defined 删除指定数据 name_list = ['Tom', 'Lily', 'Rose'] del name_list[0] print(name_list）#['Lily', 'Rose']

pop()

删除指定下标的数据(默认为最后一个)，并返回该数据,可打印出该删除的数据。

语法

列表序列.pop(下标)

name_list = ['Tom', 'Lily', 'Rose'] del_name = name_list.pop(1) print(del_name)#Lily print(name_list)#['Tom', 'Rose']

remove()

移除列表中某个数据的第一个匹配项。

语法

列表序列.remove(数据)

name_list = ['Tom', 'Lily', 'Rose'] name_list.remove('Rose') print(name_list)#['Tom', 'Lily']

clear()清空列表

清空列表中的所有元素

语法

list.clear()

my_list = [1, 2, 3, 4, 5] print("原始列表:", my_list)#原始列表: [1, 2, 3, 4, 5] my_list.clear() print("清空后的列表:", my_list)#清空后的列表: []

修改

修改指定下标数据

name_list = ['Tom', 'Lily', 'Rose'] name_list[0] = 'aaa' print(name_list)#['aaa', 'Lily', 'Rose']

逆置：reverse()

num_list = [1, 5, 2, 3, 6, 8] num_list.reverse() print(num_list)#[8, 6, 3, 2, 5, 1]

排序：sort()

语法

列表序列.sort( key=None, reverse=False)

注意：reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）

快速体验

num_list = [1, 5, 2, 3, 6, 8] num_list.sort() print(num_list）#[1, 2, 3, 5, 6, 8]

复制：copy()浅拷贝

name_list = ['Tom', 'Lily', 'Rose'] name_li2 = name_list.copy() print(name_li2）#['Tom', 'Lily', 'Rose']

深拷贝和浅拷贝之间主要区别在于：

1.拷贝对象不同。当原始对象有子对象时，浅拷贝会使用子对象的引用，而深拷贝会复制子对象。深拷贝一般用于复杂数据结构的拷贝，浅拷贝用于一些简单数据结构的拷贝。

2.对拷贝对象的处理方式不同。在浅拷贝中，如果修改被引用的对象，则原始对象和浅拷贝对象的子对象都将发生变化。而在深拷贝中，即使修改被引用的对象，深拷贝对象和原始对象的子对象之间也没有任何联系。

3.应用场景不同。深拷贝通常比浅拷贝效率更低，但在复制大型数据集时，深拷贝的优势更加明显。此外，深拷贝不仅可以用于复制对象，还可以用于将对象存储在内存中，例如在使用多个线程或多个进程时。

字典

字典里面的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可

字典特点：

符号为大括号

数据为键值对形式出现

各个键值对之间用逗号隔开

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男','aihao'[1,12,3]}#有数据字典 dict2 = {}#空字典 dict3 = dict()

获取

print(dict1)#{'name': 'Tom', 'age': 20, 'gender': '男','aihao'[1,12,3]} print(dict1['aihao'][1])#12

注意：

⼀般称冒号前面的为键key，简称k；冒号后面的为值value，简称v。
字典的键必须要可哈希（不可变数据类型【字符串、元组】）

字典的操作

（1）增加/修改

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} dict1['name'] = 'Rose' print(dict1)#{'name': 'Rose', 'age': 20, 'gender': '男'} dict1['id'] = 110 print(dict1)#{'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110} 注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对

copy()浅拷贝

update([other]): 更新字典，以其他字典或键-值对序列（iterable）中的键值覆盖当前字典中的相应值。

fruit_dict = {'apple': 1, 'banana': 2} fruit_dict.update({'apple': 4,'orange': 3, 'watermelon': 4})# 用新字典更新旧字典，有则修改，无则添加 print(fruit_dict) # 输出 {'apple': 4, 'banana': 2, 'orange': 3, 'watermelon': 4}

（2）删除 ① del()或del删除字典或删除字典中指定键值对

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} del dict1['gender'] print(dict1)#{'name': 'Tom', 'age': 20}

②clear()清空字典

③pop()也可以用于字典

popitem(): 随机删除并返回一个（键，值）对元组。

dic= {'k1':'jason','k2':'Tony','k3':'JY'} item = dic.popitem() # 随机删除一组键值对,并将删除的键值放到元组内返回 print（dic）#{'k3': 'JY', 'k2': 'Tony'} print（item）#('k1', 'jason')

（3）查询 ① key-value查找

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} print(dict1['name']) # Tom print(dict1['id']) # 报错

② get()

字典序列.get(key, 默认值)

注意：如果当前查找的key存在则返回其对应的value值，不存在则返回第⼆个参数(默认值)，如果省略第⼆个参数，则返回None，不报错。

③ values()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} print(dict1.values()) # dict_values(['Tom', 20, '男'])

④ keys()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])

⑤ items()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender','男')])

（4）遍历 ① key

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

for key in dict1.keys():

print(key)

② value

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

for value in dict1.values():

print(value)

③ item

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

for item in dict1.items():

print(item)

④ 键值对

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

for key, value in dict1.items():

print(f'{key} = {value}')

⑤setdefault(key[, default]): 如果键存在，则返回其值，否则将键插入字典并返回默认值（如果提供了）或 None。

1.key不存在则新增键值对，并将新增的value返回 dic={'k1':111,'k2':222} res=dic.setdefault('k3',333) print（res）# 333 print（dic） # 字典中新增了键值对 #{'k1': 111, 'k3': 333, 'k2': 222} 2.key存在则不做任何修改，并返回已存在key对应的value值 dic={'k1':111,'k2':222} res=dic.setdefault('k1',666) print（res）#111 print（dic）# 字典不变#{'k1': 111, 'k2': 222}

集合

集合的创建

创建集合使用 {}或set() ，但是如果要创建空集合只能使用set() ，因为{} 用来创建空字典。

s1 = {10, 20, 30, 40, 50} print(s1) # {50, 20, 40, 10, 30} s2 = {10, 30, 20, 10, 30, 40, 30, 50} print(s2) # {50, 20, 40, 10, 30} s3 = set('abcdefg') print(s3) # {'f', 'c', 'd', 'g', 'a', 'b', 'e'} s4 = set() print(type(s4)) # <class 'set'> s5 = {} print(type(s5)) # <class 'dict'>

注意：

集合可以去掉重复数据；
集合数据是无序的，故不支持下标
集合内的元素必须是可哈希（不可变）的，但是集合本身是不可哈希（可变）的

集合的运算

set1 ={1，2，3，4，5} set2 ={4，5，6，7，8} print(set1 & set2)#{4，5}交集,取出两个集合都存在的内容 print(set1 | set2)#{1，2，3，4，5，6，7，8}并集,将两个集合去重合并 print(set1 - set2)#{1，2，3}差集，第一个集合去掉和第二个集合相同的内容 print(set1 A set2)#{1，2，3，6，7，8}反交集,合并两个集合并且都去掉重合的内容，把脚踩2只船的人T出去 set1 ={1，2，3} set2={1，2，3，4，5，6} print(set1 < set2)#True子集 print(set2 > set1)#True超集/父集

集合的操作

（1）增加 ① add()增加单个数据

注意：因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进行任何操作。

s = set() s.add((1, 2, 3)) print(s) # {(1, 2, 3)}

add也可以添加序列，但是序列必须可哈希

② update() 增加序列

s1 = {10, 20} s1.update(100) #报错 s1.update([100, 200])#无序 s1.update('abc') print(s1) # {100, 'b', 200, 10, 'a', 20, 'c'}

（2）删除 ① remove()删除集合中的指定数据，如果数据不存在则报错

s1 = {10, 20} s1.remove(10) print(s1) s1.remove(10) # 报错 print(s1)

② pop()随机（因为集合无序）删除集合中的某个数据，并返回这个数据

s1 = {10, 20, 30, 40, 50} del_num = s1.pop() print(del_num) print(s1)

③ discard()删除集合中的指定数据，如果数据不存在也不会报错

s1 = {10, 20} s1.discard(10) print(s1) s1.discard(10) print(s1)

（3）查找

in：判断数据在集合序列

not in：判断数据不在集合序列

（4）方法

print(set1.isdisjoint(set2))#判断2个集合是不是不相交，返回True or False print(set1.issubset(set2))#判断set1是不是set2的子集，返回True or False print(set2.issuperset(set1))#判断set1是不是set2的父集，返回True or False print(set1.union(set2))#并集,将两个集合去重合并 print(set1.intersection(set2))#交集,取出两个集合都存在的内容 print(set1.symmetric_difference(set2))#反交集,合并两个集合并且都去掉重合的内容，把脚踩2只船的人T出去 print(set1.difference(set2))#差集,第一个集合去掉和第二个集合相同的内容

循环判断

判断语句

1、if 语句：单分支

if语句是最简单的判断语句。一般形式如下：

if condition:

statement_block

只有当判断条件condition为真时，才能执行代码块。当判断条件condition为假时，statement_block不执行。

案例：设置变量age表示年龄，通过判断age的值输出不同内容。代码如下：

age = 23 # 设置变量age=23 if age >= 18: # 判断条件 print("成年人")

当变量符合条件时，运行的结果为：

如果变量不符合条件是不会执行代码的。

2、if-else语句：双分支

根据python中的判断规则，当条件成立时，执行if后面的代码块，当条件不成立时，则不执行其后的代码块。if-else的语句一般格式如下：

if condition：

statement_block

else：

statement_block2

上述格式中，当判断条件成立时，才可以执行代码块statement_block；当不满足判断条件时，执行statement_block2。

案例：使用 if-else 语句判断输入年龄是否成年。代码如下

age = 23 # 设置变量age=23 if age >= 18: # 判断条件 print("成年人") # 判断条件为真时执行的代码 else: print("未成年人") # 判断条件为假时执行的代码

运行结果如下：

当判断条件成立时，执行 if 下面的代码块，否则执行 else 下面的代码块。

3、if-elif 语句：多分支

if-elif语句可以用来判断多种情况。一般格式如下：

if condition1：

statement_block1

elif condition2：

statement_block2

elif condition3：

statement_block3

if 是判断语句，elif 也是判断语句，但是 elif 可做到更细致的判断。

（1）当满足 if 判断条件 condition1 时，则执行代码块 statement_block1，接下来整个 if 条件结束；

（2）如果不满足 if 判断条件condition1，满足判断条件condition2，则执行代码块statement_block2，接下来整个 if 条件结束；

（3）如果不满足判断条件condition1和判断条件condition2，满足判断条件condition3，则执行代码块statement_block3，接下来整个 if 条件结束。

案例：某商场做周年庆活动，购买100元以上，用户可以享受9折优惠；购300元以上就可以享受8折优惠；购买500元以上即可享受7折优惠。

amount = 400 if amount < 100: print("用户没有优惠，需要支付金额:") print(amount) elif 300 > amount >= 100: print("用户享有9折优惠，需要支付金额:") print(amount*0.9) elif 500 > amount >= 300: print("用户享有8折优惠，需要支付金额:") print(amount*0.8) elif amount >= 500: print("用户享有7折优惠，需要支付金额:") print(amount*0.7)

运行结果为：

4、嵌套判断

嵌套判断语句可以用于多条件、多层次的逻辑判断
嵌套判断语句可以根据需求，自由组合if elif else来构建多层次判断
嵌套判断语句，一定要注意空格缩进，Python通过空格缩进来决定层次关系

例：

if int(input("你的身高是多少：")) > 120: # 1 print("身高超出限制，不可以免费") print("但是，如果vip级别大于3，可以免费") if int(input("你的vip级别是多少：")) > 3: # 2 print("恭喜你，vip级别达标，可以免费") else: print("Sorry 你需要买票10元") else: print("欢迎小朋友，免费游玩。")

5、多条件判断

使用and或or来连接多个条件表达式，比如条件1 and 条件2 and条件3等等，当使用and连接多个表达式时，只要其中一个表示式为False，则if的条件为False，否则为True，相反，or连接的表达式中，只要有一个表达式为True，则if的条件为True，否则为False；
and和or的混合使用，二者的优先级按前后顺序执行；
使用比较运算符，比如 1<=x >=2；

6、match-case判断

Python3.10以上版本可用

num=3 match (num): case 1: print("今天周一") case 2: print("今天周二") case 3: print("今天周三") case 4: print("今天周四") case 5: print("今天周五") case 6: print("今天周六") case 7: print("今天周日") case _: print("内容有误") #今天周三

7、三元运算符

num = 2

if num>=0:

num +=1

else:

num -= 1

c = num = 1 if num >= 0 else num - 1

print(c)#1

循环语句

for循环

for 循环用于迭代序列（即列表，元组，字典，集合或字符串）。
for 循环不需要预先设置索引变量。

语法

for 临时变量 in 序列: # 序列所有可以使用下标取值或者字典重复执行的代码1 重复执行的代码2

while循环

while的语法

while 条件: 条件成立重复执行的代码1 条件成立重复执行的代码2

与for循环类似

for … else 语句

for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。

for num in range(10,20): # 迭代 10 到 20 之间的数字 for i in range(2,num): # 根据因子迭代 if num%i == 0: # 确定第一个因子 j=num/i # 计算第二个因子 print('%d 等于 %d * %d' % (num,i,j)) break # 跳出当前循环 else: # 循环的 else 部分 print('%d 是一个质数' % num)

range() 函数

使用 range() 函数循环一组代码指定的次数

range() 函数返回一个数字序列，默认情况下从 0 开始，并递增 1（默认），并以指定的数字结束。

for i in range(10):

print(i)

注：i 地址从0开始到设置数前一位数结束，如打印10是从0打印到9

range() 函数默认将序列递增 1，但是可以通过添加第三个参数来指定增量值：

for i in range(0,10,3):#将序列递增 3

print(i)#0 3 6 9

enumerate() 函数

枚举（enumerate）允许我们遍历数据并自动计数。创建包含索引的元组列表。

my_list = ['apple', 'banana', 'grapes', 'pear'] for counter, value in enumerate(my_list): print(counter, value)

结果(0, 'apple') (1, 'banana') (2, 'grapes') (3, 'pear')

循环控制语句

循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句：

break 语句

break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。

break语句用在while和for循环中。

使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。

for letter in 'Python': if letter == 'h': break print('当前字母 :', letter)

continue 语句

continue 语句跳出本次循环，而break跳出整个循环。

continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。

continue 语句用在while和for循环中。

for letter in 'Python': if letter == 'h': continue print('当前字母 :', letter)

pass 语句

Python pass 是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句。

for letter in 'Python':

if letter == 'h':

pass

print('这是 pass 块')

print('当前字母 :', letter)

函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

定义

规则：函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 () 。任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。函数内容以冒号起始，并且缩进。

return 表达式 #返回结束函数return同级后面代码不执行，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。return后可接多种类型可接多个值

语法

def func(str):

"打印任何传入的字符串"

print(str)

return

函数调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。

如下实例调用了 func()函数

def func(str):#打印任何传入的字符串 print(str) return #调用函数 func()#调用func函数 func()#再次调用func函数

参数传递

位置传参

def t1(c):#形参 if c<70: print("不及格") elif c< 90: if c< 80: print("及格") else: print("良好") else: print("优秀") t1(69)#实参#####不及格

关键字传参

def sum(n1, n2): print("n1====",n1) print("n2====",n2) print(n1+n2) sum(10,20)#n1==== 10 #n2==== 20 #30 #关键字传参 sum(n2=10,n1=20)#n1==== 20 #n2==== 10 #30

可变的位置参数和关键字参数

参数只能定义一个，但是在一个函数的定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参，要求个数可变的位置形参，放在个数可变的关键字形参之前

#个数可变的位置参数 def fun(*args): print(args)#返回元组 fun(10)#(10,) fun(10,20)#(10, 20) fun(20,34,55)#(20, 34, 55) #个数可变的关键字形参 def fun1(**args): print(args)#返回字典 fun1(a=10)#{'a': 10} fun1(a=20,b=90,c=89)#{'a': 20, 'b': 90, 'c': 89}

例：

函数嵌套调用

所谓函数嵌套调用指的是==一个函数里面又调用了另外一个函数==。

示例

def testB(): print('---- testB start----') print('这里是testB函数执行的代码...(省略)...') print('---- testB end----') def testA(): print('---- testA start----') testB() print('---- testA end----') testA()

def c(): print("这是c函数") def d(): print("这是d函数") return d value = c() value()

def f(): print("f函数") def aa(a): print("aa函数") f() aa(f)

匿名函数

使用lambda创建匿名函数，所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

语法

lambda [arg1 [,arg2,.....argn]]:expression

例：

lambda s1,s2: s1 + s2

print((lambda s1,s2: s1 + s2)(2,3))#5

lambda 只是一个表达式，函数体比 def 简单很多。

lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

递归函数

如果一个函数调用了自己，那我们称这个函数为递归函数

递归函数必须有终止条件。 def f(x) :

return f(x-1)+x

print(f(3))

闭包函数

闭包函数是指在一个函数内部定义的函数，并且内部函数可以访问外部函数的变量。

#outer不是闭包函数，inner是闭包，引用外层的作用于函数的变量 def outer(a): def inner(): return a**2 return inner #outer不是闭包函数，inner也不是闭包，没有引用外层作用域的变量 b = 1 def outer(): def inner(): return b**2 return inner

装饰器函数

【1】定义和作用

装饰器的作用就是在不修改被装饰对象源代码和调用方式的前提下为被装饰对象添加额外的功能。

装饰器经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等应用场景，装饰器是解决这类问题的绝佳设计，有了装饰器，就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。

【2】普通函数到无参装饰器的转变（例：时间性能测试）（1）函数作为参数

将函数地址传入，返回的直接是执行结果

返回值看着不便，希望直接是函数名

import time def func1(): time.sleep(1.1) print("func1开始运行") def func2(): time.sleep(1.2) print("func2开始运行") def test_time(func): start_time = time.time() res = func() end_time = time.time() msg = f"{func}运行：{round(end_time - start_time, 2)}" return msg res = test_time(func1) print(res) res = test_time(func2) print(res) #func1开始运行 #<function func1 at 0x000001D7E63D3E20>运行：1.1 #func2开始运行 #<function func2 at 0x000001D7E6503910>运行：1.2

（2）将值给闭包函数

可以使用同名变量接收函数

返回地址后还需要添加括号运行

import time def func1(): time.sleep(1.1) print("func1开始运行") def func2(): time.sleep(1.2) print("func2开始运行") def test_time(func): def inner(): start_time = time.time() res = func() end_time = time.time() msg = f"{func}运行：{round(end_time - start_time, 2)}" return msg return inner func1 = test_time(func1) print(func1()) func2 = test_time(func2) print(func2()) #func1开始运行 #<function func1 at 0x000001D7E63D3E20>运行：1.1 #func2开始运行 #<function func2 at 0x000001D7E6503910>运行：1.2

（3）语法

可以直接使用原函数名称

装饰器函数需要定义在所有调用装饰器函数的最上方

import time def test_time(func): def inner(): start_time = time.time() res = func() end_time = time.time() msg = f"{func}运行：{round(end_time - start_time, 2)}" return msg return inner @test_time # 等价于 func1 = test_time(func1) def func1(): time.sleep(1.1) print("func1开始运行") @test_time # 等价于 func2 = test_time(func2) def func2(): time.sleep(1.2) print("func2开始运行") print(func1()) print(func2()) #func1开始运行 #<function func1 at 0x000001D7E63D3E20>运行：1.1 #func2开始运行 #<function func2 at 0x000001D7E6503910>运行：1.2

（4）需要数据传递时（*args、**kwargs）

import time def test_time(func): def inner(*args, **kwargs): start_time = time.time() res = func(*args, **kwargs) end_time = time.time() msg = f"{func}运行：{round(end_time - start_time, 2)}" return msg return inner @test_time # 等价于 func1 = test_time(func1) def func1(*args, **kwargs): print("func1开始运行") time.sleep(1.1) str1 = args[0] name = kwargs.get("name") print(f"{name}, {str1}") print(func1("hello, world", name="tom")) # func1开始运行 # tom, hello, world # <function func1 at 0x0000022D1AD33910>运行：1.1

（5）无参装饰器模板

def decorator(func): # 装饰器声明时操作 def inner(*args, **kwargs): # 函数执行前操作 res = func(*args, **kwargs) # 函数执行后操作 return res return inner

【3】多层装饰器执行顺序

代码讲解

def decorator1(func): print("装饰器1--被应用") def inner(*args, **kwargs): print("装饰器1--函数执行前操作") # 3. res = func(*args, **kwargs) print("装饰器1--函数执行后操作") # 7. return res return inner def decorator2(func): print("装饰器2--被应用") def inner(*args, **kwargs): print("装饰器2--函数执行前操作") # 4. res = func(*args, **kwargs) print("装饰器2--函数执行后操作") # 6. return res return inner @decorator1 # 2. 打印装饰器1--被应用 @decorator2 # 1. 打印装饰器2--被应用 def func1(): print("函数--开始工作") # 5. func1() # 装饰器2--被应用 # 装饰器1--被应用 # 装饰器1--函数执行前操作 # 装饰器2--函数执行前操作 # 函数--开始工作 # 装饰器2--函数执行后操作 # 装饰器1--函数执行后操作