一、python 基本操作
1、常见pep8规范：
PEP 8是Python社区普遍采用的一份编码规范，包括代码风格、命名规范、代码布局等方面的约定。遵守PEP 8可以让你的代码更加易读易懂、易于维护，提高代码质量。以下是PEP 8的一些重要规范：
函数和方法的命名
函数和方法的命名应该使用小写字母，单词之间用下划线分隔，以便于阅读和理解。
函数和方法的名称应该是动词或动词短语，以描述函数执行的操作。
类方法的第一个参数应该命名为self，表示实例对象本身。
模块级函数应该使用简洁的、描述性的名字，避免使用单个字符的名称。
示例：
pythonCopy code# 函数名使用小写字母，单词之间用下划线分隔
def calculate_average(numbers_list):
total = sum(numbers_list)
return total / len(numbers_list)
方法名也遵循相同的规则
class Circle:
def calculate_area(self, radius):
return 3.14 * radius ** 2
类的命名
类的命名应该使用驼峰命名法，即每个单词的首字母大写，单词之间无下划线。
类的名称应该是名词或名词短语，以描述类的含义。
示例：
pythonCopy code# 使用驼峰命名法命名类
class BankAccount:
def init(self, balance):
self.balance = balance
def deposit(self, amount):
self.balance += amount
def withdraw(self, amount):
self.balance -= amount
变量的命名
变量的命名应该使用小写字母，单词之间用下划线分隔。大小写敏感。
变量的名称应该是名词或名词短语，以描述变量的含义。
常量应该全部大写，单词之间用下划线分隔。
示例：
pythonCopy code# 使用小写字母和下划线命名变量
total_price = 0
tax_rate = 0.05
#常量全部大写，单词之间用下划线分隔
MAX_RETRY_COUNT = 5
空格的使用
在二元操作符两侧应该留出一个空格。
在逗号、冒号、分号前不要加空格，而在它们后面应该加一个空格。
在函数的参数列表、索引和切片的左括号前不应有空格。
示例：
pythonCopy code# 二元操作符两侧应该留出一个空格
x = 10 + 2
#在逗号、冒号、分号前不要加空格，而在它们后面应该加一个空格
def calculate_sum(x, y):
return x + y
for i in range(10):
print(i)
#在函数的参数列表、索引和切片的左括号前不应有空格
result = calculate_sum(10, 20)
message = “hello world”[0:
代码缩进
缩进应该使用四个空格，而不是制表符。
所有代码块应该缩进，包括if语句、while语句、for循环等。
示例：
pythonCopy code# 使用四个空格进行缩进
def print_names(names_list):
for name in names_list:
if len(name) > 5:
print(name)
else:
print("Name is too short.")
# 所有代码块应该缩进
while True:
print("This is an infinite loop.")
文档字符串
每个函数、方法和类应该包含文档字符串，以解释它们的用途和行为。
文档字符串应该在函数、方法或类的定义行之后紧跟着。
文档字符串应该使用三个引号（“”"）括起来，而不是两个单引号或双引号。
示例：
pythonCopy codedef calculate_sum(numbers_list):
"""
计算列表中所有数字的总和。
参数：
numbers_list：数字列表
返回值：
总和
"""
return sum(numbers_list)
导入
导入语句应该在文件顶部，位于模块注释和全局变量之后，函数和类定义之前。
每个导入应该独占一行。
导入语句应该按照标准顺序进行分组，每组之间应该用一个空行分隔。
示例：
pythonCopy code"""
这是一个演示模块
"""
import os
import sys
import numpy as np
import pandas as pd
from my_module import MyClass
这些是PEP 8中的一些重要规范和示例，但并不是全部。遵循这些规范可以使代码更易于阅读、理解和维护
2、pycharm中一键格式化代码：
根据Problems逐一修复
二、python 基本数据类型
1、变量
存储数据的载体，计算机系统中实际存在的数据，变量值可以被读取和修改
2、数字
常见数据类型： int-整形 float-小数
常用运算操作：
赋值=： a=1
加减乘除 ±/ ：12=2
取余 % ：11%2=2
乘方**：3**3=27
修改运算符()：（1+4)/2=2
等于 == ：返回布尔 1==1 True
不等于!=:
3、布尔boolean
True False
4、字符串string
\ 转义符
r 原字符，忽略转义
+字符串链接
索引 ：str_a=“abcdef” str_a[0]=“a” 从0开始
切片 [:]：前闭后开
取中间2个 str_a[2:4]=“cd”
全部 str_a[:]=“abcdef”
倒序 str_a[-1:]=“f”
步长 start: stop: step 默认为1 str_a[0:5:2]=“ace”
三、python 字符串基本操作
1、字符串定义：
单行a=“x” 多行a=“”" xx"“”
2、常用特殊字符：
常见转义
\n 换行
\ 转义 \n
3、格式化
%s 格式化字符串
a=“神” print(“我是%s”%a)
%d 格式化整数
%f 格式化浮点数字
4、字面量插值
“str”.format()
#不指定位置，按默认顺序
a="{} {}".format("h","e") print(a)
#设置指定位置
a="{0} {1}".format("h","e")
print(a) b="{1} {0}".format("h","e")
print(b)
#通过名称传递变量
c="我的性别是{sex}".format(sex="男")
5、优雅的格式化
a="神" print(f"我是{a}")
6、常用api
#1、元素拼接join
hello a=["h","e","l","l","o"] print("".join(a))
#join将元素根据｜拼接
h｜e｜l｜l｜o print("｜".join(a))
#2、切分split
['my', 'name'] a="my name" print(a.split())
#3、替换replace
my name is b a="my name is a" print(a.replace("a","b"))
#4、取消首位空格strip=>my name a=" my name " print(a.strip())
四、python 运算符
#1、算术运算符
a,b=4,2
print(a+b) #加 6
print(a-b) #减 2
print(a*b) #乘 8
print(a/b) #除 2.0
print(a%b) #取模 0
print(a**b) #幂 16
print(a//b) #整除 2
b=3
print(a//b) #整除 向下取整1 4/3=1.33333=1
b=2.65
print(a//b) #整除 向下取整4/2.65=1.50943=1.0
#2、比较运算符
a,b=4,2
print(a==b) #等于 False
print(a!=b) #不等于 True
print(a>b) #大于 True
print(a<b) #小于 False
print(a>=b) #大于等于 False
print(a<=b) #小于等于 False
#3、赋值运算符
a=1 #简单赋值
print(a)
a,b=1,2 #多个变量赋值
print(a)
print(b)
a+=1
print(a) #加法赋值 自增 a=a+1 <==> a+=1 1+1=2
a-=1
print(a) #减法赋值 自减 2-1=1
a*=1
print(a) #乘法赋值 2*1=2
a/=1
print(a) #除法赋值 2/1=2
a%=1
print(a) #取模赋值 2/1=2 余数为0.0
a=2
a**=1
print(a) #幂赋值 2^1=2
a=2
a//=1
print(a) #整除赋值 2/1=2
#4、逻辑运算符 and or not
a,b=1,2
print(a==1 and b==2) #True
print(a==1 or b==2) #True
print(not a==1) #False
#5、成员运算符 in 、not in 右边是序列
a=[1,2,3]
b=1
print(b in a) #True
print(b not in a) #False
#6、身份运算符 is 、is not
a=[1,2,3]
b=[1,2,3]
print(a is b) #False 内存地址不一致
print(id(a))
print(id(b))
print(a is not b) #True
print(a==b) #True
7、is与==区别：is会判断内存地址相同 id(a)
#可变数据结构，内存地址不同
#不可变数据结构，内存地址相同
8、 运算符优先级
高到低口决：算位比 身成逻
【算术(±*/)、位(二进制)、比较（== > <）、身份(is /is not)、成员(in/not in)、逻辑（非与或）】
优先级：当多个运算符同时出现在一个表达式中时，先执行哪个运算符。
结合性：默认左，当一个表达式中出现多个优先级相同的运算符时，先执行哪个运算符：先执行左边的叫左结合性，先执行右边的叫右结合性
五、python 控制流-判断
1、什么是分支判断
2、if判断语句
3、else判断语句
4、elif 多重条件
if xx:
elif xx:
elif xx:
else:
xx
5、分支嵌套
if xx:
if xx:
else:
xx
else:
xx
6、三目运算符
h="变量1" if a>b else "变量2"
六、python 控制流-循环
1、什么是循环
2、for-in循环
使用场景：明确循环次数、或对容器进行迭代
range函数：
1） 传入一个参数，传入的是结束数值 前闭后开
range（101）产生0-100的整数序列
2）传入两个参数，传入的是开始、结束数值
range（1，100） 产生0-99的整数序列
3）传入三个参数，传入的是开始、结束数值、步长
range(0,101,2) 产生1到100的偶数序列 0 2 4…100
3、while循环
使用场景：满足条件时进入循环，需要设定结束条件，不然死循环
4、break 跳出整个循环
5、continue 跳出当前循环进入下一循环
6、pass 占位符
# 1、for in 循环
# 构造0-100的偶数序列
for i in range(0,101,2):
print(i)
# 2、while循环
count = 0
while count < 100:
count += 1
print(count)
if count == 3:
pass # pass占位
elif count == 9:
break # 跳出整个循环
else:
continue # 跳出当次，进入下一循环
# 3、练习
# 3-1、使用分支结构实现1~100之间的偶数求和
sum,end=0,100
for i in range(1,end+1):
if i%2==0:
sum+=i
else:
continue
print(sum)
#3-2、不使用分支结构实现1~100之间的偶数求和
sum,end=0,100
for i in range(0,end+1,2):
sum += i
print(sum)
"""猜数字游戏
计算机出一个1~100之间的随机数由人来猜
计算机根据人猜的数字分别
给出提示大一点/小一点/猜对了"""
while True:
computer_num = random.randint(1, 100)
people_num = int(input("请输入数字："))
if people_num<computer_num:
print(f"电脑数字为：{computer_num}")
print(f"你的数字为：{people_num}")
print("大一点")
elif people_num>computer_num:
print(f"电脑数字为：{computer_num}")
print(f"你的数字为：{people_num}")
print("小一点")
else:
print(f"电脑数字为：{computer_num}")
print(f"你的数字为：{people_num}")
print("猜对了")
break
"""课后练习
奇数-不能被2整除的数
"""
#不使用分支结构实现1~100之间的奇数求和
sum=0
for i in range(1,100,2):
print(i)
sum+=i
print(f"1~100之间的奇数求和为：{sum}")
#使用while语句实现1~100之间的奇数求和
num,sum=0,0
while num<100:
num+=1
print(f"num:{num}")
if num%2 !=0:
sum+=num
print(f"sum:{sum}")
else:
continue
print(f"1~100之间的奇数求和为：{sum}")
七、 python 常用数据结构-列表
"""一、列表的定义
列表是有序的可变元素的集合，使用中括号[]包围，元素之间用逗号分隔
列表是动态的，可以随时扩展和收缩
列表是异构的，可以同时存放不同类型的对象
列表中允许出现重复元素"""
"""二、列表的使用：创建"""
#1.构造方法
list_a=list()
print(type(list_a),list_a)
#2、中括号填充元素
list_b=[1,"a",{"a":1},[1,2],(1,2,3)]
#3、列表推导式
list_c=[i for i in range(1,10)if i%2==0]
print(type(list_c),list_c)
"""三、列表的使用：索引/切片"""
#1、索引 （正索引，0开始；负索引，-1开始）
list_d=[1,2,3,4,5]
print(list_d[0]) #首个元素
print(list_d[-1]) #最后元素
#2、切片 获取多个元素
# [start:stop:step] 三种方式同前面rangestep-步长默认为1
#基本方法
li=['h','o','g','w','a','r','t','s']
print(li[0:5:2]) #第一个到第五个元素中按步长2 ['h', 'g', 'a']
print(li[2:4]) #第3个到第4个元素 'g', 'w']
print(li[:4]) #第1个到第4个元素 ['h', 'o', 'g', 'w']
print(li[2:]) #第3个到最后 ['g', 'w', 'a', 'r', 't', 's']
print(li[::2]) #全部元素，按步长2 ['h', 'g', 'a', 't']
print(li[::-1]) #全部元素，按步长2，倒序打印['s', 't', 'r', 'a', 'w', 'g', 'o', 'h']
"""三、列表的使用：运算符
重复：使用 * 运算符可以重复生成列表元素。
合并：使用 + 加号运算符，可以将两个列表合二为一。"""
# 1、* 重复生成列表元素
li1=[1]
print(li1*5) #[1, 1, 1, 1, 1]
# 2、+ 列表合并
li2=[1,2,3]
li3=[4,5,6]
print(li2+li3) #[1, 2, 3, 4, 5, 6]
"""四、列表的使用：成员检测
in：检查一个对象是否在列表中，如果在则返回 True，否则返回 False。
not in：检查一个列表是否不包含某个元素。如果不在返回 True，否则返回 False。"""
li1=[1,2,3]
print(1 in li1) #True
print(1 not in li1) #False
print(4 in li1) #False
print(4 not in li1) #True
"""五、列表方法"""
li=[1,2,3]
#扩展加元素
#1、append(item)
# 将一个对象item添加到列表末，入参-item,返回-None
li.append(4)
print(li) #[1, 2, 3, 4]
#2、extend(iterable)
# 将一个可迭代对象到所有元素，添加到列表末;入参-可迭代对象iterable;返回-None
li=[1,2,3]
li.extend('hello')
print(li) #[1, 2, 3, 'h', 'e', 'l', 'l', 'o']
li1=[1,2,3]
li2=[4,5,6]
li1.extend(li2) #[1, 2, 3, 4, 5, 6]
#3、insert(index,item)
# 将一个元素插入指定到索引位置;入参-索引值index和一个对象item;返回-None;原索引位置以及后面到元素后移一位
li=[1,2,3]
li.insert(1,"a")
print(li) #[1, 'a', 2, 3]
#缩小元素
#4、pop(index)
# 移除指定索引位置到元素；若索引值不正确则引发IndexError
# pop() 默认移除最后一个元素
li=[1,2,3]
li.pop(2)
print(li) #删除第三个元素，[1, 2]
li.pop() #删除最后元素，[1]
#2种异常情况
print(li)
li.pop(3) #IndexError: pop index out of range
li=[]
li.pop() #IndexError: pop from empty list
#5、remove(item)
# 移除列表第一个等于item的元素，入参-item，返回-None，目标元素必须存在，否则ValueError
li=[1,2,3]
li.remove(1) #[2, 3]
print(li)
li.remove(4) #ValueError: list.remove(x): x not in list
#排序
#6、sort(key=None,reverse=Flase)
#对列表进行原地排序，只使用<来进行元素比较
#入参：支持2个关键字
#key:指定带有一个参数的函数，用于从每个列表元素种提取比较键
#reverse:默认值为False表示升序，为True表示降序
#返回：None
#1)不传参数，默认升序，数字从小到大排序
li=[2,4,3,1]
li.sort()
print(li) #1, 2, 3, 4]
#2）指定key=len,按元素的长度排序
words=["python","go","java","c"]
words.sort(key=len)
print(words) #['c', 'go', 'java', 'python']
#3）指定reverse=True,降序
nums=[2,4,3,1]
nums.sort(reverse=True)
print(nums) #[4, 3, 2, 1]
#7、反转 reverse
"""reverse():将列表元素反转
参数：无
返回：None
反转只是针对索引值，元素间不互相比较"""
nums=[5,3,2,4,1]
nums.reverse()
print(nums) #[1, 4, 2, 3, 5]
"""六、列表嵌套
嵌套列表是指在列表里存放列表
列表的常用方法都适用于嵌套列表"""
#1、创建嵌套列表
list1=[[1,2,3],['a','b','c']]
print(type(list1)) #<class 'list'>
print(len(list1)) #2
#2、访问嵌套列表中的元素
print(list1[0][2]) #3
"""七、列表推导式
列表推导式是指循环创建列表，相当于 for 循环创建列表的简化版
语法：[x for x in li if x ...]"""
#实例：将1-10中所有的偶数开方后组成新的列表
#1、传统
result=[]
for e in range(1,11):
if e%2==0:
result.append(e**2)
print(result) #[4, 16, 36, 64, 100]
#2、列表推导式
result=[e**2 for e in range(1,11) if e%2==0 ]
print(result) #[4, 16, 36, 64, 100]
八、python 常用数据结构-元组
"""一、元祖定义：
元祖是有序的不可变对象的集合
元祖使用小括号(),各个对象之间使用逗号，分隔
元祖是异构的，可以包含多种数据类型"""
"""二、元祖的使用：创建"""
# 1、直接使用逗号分隔
tup1 = 1, 2, 3, 4
print(type(tup1), tup1)
# 2、通过小括号填充元素
tup2 = (1, 2, 3, 4)
print(type(tup2), tup2)
# 3、通过构造函数 要为空或者可迭代对象，否则TypeError: 'xx' object is not iterable
tup3 = tuple()
print(type(tup3), tup3) # 不传默认为（）
tup4 = tuple('hello')
print(type(tup4), tup4) # 不传默认为（）
tup5 = tuple([1, 2, 3, 4, 5])
print(type(tup5), tup5) # 不传默认为（）
##异常
tup4 = tuple(1) # TypeError: 'int' object is not iterable
# 注意：单元素元祖，逗号不可缺少
tup6 = 1,
print(type(tup6), tup6) # <class 'tuple'> (1,)
tup7 = (2,)
print(type(tup7), tup7) # <class 'tuple'> (2,)
##不加逗号
tup7 = (2)
print(type(tup7), tup7) # <class 'int'> 2
"""三、元祖的使用：索引切片与列表一致"""
"""四、元祖的常用方法："""
# 1、index
# index(item)
# 返回与目标元素相匹配的首个元素的索引
# 目标值必须在元祖中存在，否则会报错
li = 1, 2, 3
print(li.index(3)) # 2
print(li.index(4)) # ValueError: tuple.index(x): x not in tuple
# 2、conut
# index(item)
# 返回某个元素出现的次数
# 返回：次数
li = (1, 2, 3, 3, 3, 3)
print(li.count(3)) # 4
print(li.count(4)) # 如果输入不存在的对象则为0 0
"""五、元祖解包
把一个可迭代对象里的元素，一并赋值到由对应的变量组成的元祖中"""
# 1、传统逐一赋值 繁琐
t = (1, 2, 3)
a = t[0]
b = t[1]
c = t[2]
print(a, b, c)
# 2、使用元祖解包，一气呵成
a, b, c = [1, 2, 3]
print(a, b, c) # 1 2 3
a, b, c = (1, 2, 3)
print(a, b, c) # 1 2 3
"""六、元祖与列表的比较"""
"""
1、相同点：
1）都是有序的
2）都是异构的，能包含不同数据类型的对象
3）都支持索引和切片
2、区别：
1）声明方式不同，元祖使用()，列表使用[]
2)列表可变支持增删改，元祖不可变
"""
九、python 常用数据结构-集合
"""一、集合的定义
无序的唯一对象集合
用大括号{}包围，对象相互之间用逗号分割
集合是动态的，可以随时添加或者删除
集合是异构的，可以包含不同数据类型的数据"""
"""二、集合的使用：创建"""
#1、通过{}创建
set1={1,2,3}
print(type(set1),set1) #<class 'set'> {1, 2, 3}
#2、通过构造方法 set(interable)
set2=set("hello")
print(type(set2),set2) #<class 'set'> {'h', 'o', 'e', 'l'}
set3=set()
print(type(set3),set3) #<class 'set'> set()
#3、通过集合推导式
set4={i for i in range(5) if i%2==0}
print(type(set4),set4) #<class 'set'> {0, 2, 4}
"""集合的使用：成员检测in/not in"""
set1={1,2,3}
print(1 in set1) #True
print(1 not in set1) #False
print(4 in set1) #False
print(4 not in set1) #True
"""三、集合常用方法"""
#1、增 add(item)
##将单个对象添加到集合中，入参-item 返回-None
set1={1,2,3}
set1.add(4)
print(set1)
#2、update(iterable)
#批量添加来自可迭代对象中的所有元素
#入参：可迭代对象iterable
#返回：None
set1=set()
set1.update("hello")
print(type(set1),set1) #<class 'set'> {'e', 'l', 'o', 'h'}
set1.update([1,2,3])
print(type(set1),set1) #<class 'set'> {1, 2, 3, 'o', 'e', 'l', 'h'}
#3、删 remove(item)
#从集合中移除指定元素
#入参：指定元素值
#返回：None
#如果item不存在集合中则会引发KeyError
#元素存在
set1={1,2,"a"}
set1.remove("a") #{1, 2}
print(set1)
#元素不存在则报错
set1.remove(3) #KeyError: 3
#4、删 discard(item)
#从集合中移除指定对象item
#入参：指定对象值 返回-None,元素item不存在没影响，不会抛出KeyError
#1）元素存在
set1={1,2,"a"}
set1.discard("a") #{1, 2}
print(set1)
#2）元素不存在则报错
set1.discard(3) #返回空
#5、随机删 pop()
#随机从集合中移除并返回一个元素
#入参：无
#返回：被移除的元祖
#如果集合为空则会引发KeyError
#1)随机删除某个对象
set1={1,2,3,4,5}
item=set1.pop()
print(item,type(item),set1) #1 {2, 3, 4, 5}
#6、全部删 clear()
#清空所有元素
set1={1,2,3,4,5}
set1.clear()
print(set1) # set()
"""四、集合运算"""
#1、交集运算 itersection &
a={1,2,3}
b={4,3,6}
print(a.intersection(b)) #{3}
print(a&b) #{3}
#2、并集运算 union |
a={1,2,3}
b={4,3,6}
print(a.union(b)) #{1, 2, 3, 4, 6}
print(a|b) #{1, 2, 3, 4, 6}
#3、差集运算 difference -
a={1,2,3}
b={4,3,6}
print(a.difference(b)) #{1, 2}
print(a-b) #{1, 2}
print(b.difference(a)) #{4, 6}
print(b-a) #{4, 6}
"""五、集合推导式
语法：{x for x in ...if...}
"""
#寻找共同abc与bcd的字母
#1、传统
set1=set()
for s in 'abc':
if s in 'bcd':
set1.add(s)
print(set1) #{'b', 'c'}
#2、简洁
set1={s for s in 'abc'if s in 'bcd'}
print(set1) #{'b', 'c'}
十、python 常用数据结构-字典
# -*- coding: utf-8 -*-
# @Time : 2023/4/23 19:13
# @Author : yanfa
# @user : yanfa
# @File : dict_.py
# @remark: 字典
""""""
"""一、字典的定义
字典是无序的键值对集合
字典用大括号{}包围
每个键值对之间用逗号（，）分隔
每个键和值用冒号（：）分隔
字典的动态的"""
"""二、字典的创建"""
#第一种：使用大括号{}
dic1={}
dic2={"a":1,"b":[1,2]}
#第二种:构造方法
dic3=dict()
dic4=dict([("a",1),("b",2)]) #{'a': 1, 'b': 2}
print(dic4)
#第三种，推导式
dic_5={k:v for k,v in [("a",1),("b",2)]}
"""三、字典的使用：访问元素
支持括号记法[key]
字典使用键来访问其关联的值
访问时对应的key必须要存在"""
dic_6={"a":1,"b":[1,2]}
#1、访问存在的key
print(dic_6["a"]) #1
#2、访问不存在的key
# print(dic_6["c"]) #KeyError: 'c'
"""三、字典的使用：操作元素
语法：dict[key]=value
添加元素-键不存在：
修改元素-键存在"""
#1、添加元素
dic_6["c"]=2
print(dic_6) #{'a': 1, 'b': [1, 2], 'c': 2}
#2、修改元素
dic_6["c"]=3
print(dic_6) #{'a': 1, 'b': [1, 2], 'c': 3}
"""四、字典使用：嵌套字典
字典的值也可以是字典对象"""
dic_6={"a":{"b":1}}
print(dic_6["a"]["b"]) #1
"""五、字典方法"""
dic_7={"a":1,"b":[1,2]}
#1、keys(),# 返回视图对象，通过list()将视图转成列表
print(dic_7.keys()) #dict_keys(['a', 'b'])
print(list(dic_7.keys())) #['a', 'b']
#2、values()
print(dic_7.values()) #dict_values([1, [1, 2]])
print(list(dic_7.values())) #[1, [1, 2]]
#3、items()
print(dic_7.items()) #dict_items([('a', 1), ('b', [1, 2])])
print(list(dic_7.items())) #[('a', 1), ('b', [1, 2])]
#4、get() 找不到不报错，返回None。方法的好处是无需担心 key 是否存在，永远都不会引发 KeyError 错误
dic_8={"a":1,"b":2,"c":3}
print(dic_8.get("a")) #1
print(dic_8.get("d")) #None
#5、update，使用来自 dict 的键/值对更新字典，覆盖原有的键和值。
dic_9={"a":1,"b":2,"c":3}
data={"b":20,"d":4}
dic_9.update(data)
print(dic_9) #{'a': 1, 'b': 20, 'c': 3, 'd': 4}
#6、pop() 删除指定 key 的键值对，并返回对应 value 值。
dic_10={"a":1,"b":2,"c":3}
print(dic_10.pop("a")) #如果 key 存在于字典中，则将其移除并返回 value 值 1
print(dic_10.pop("d")) #如果 key 不存在于字典中，则会引发 KeyError。
#7、clear() 清空元素
dic_11={"a":1,"b":2,"c":3}
dic_11.clear()
print(dic_11) #{}
#8、copy() 拷贝
dic_12={"a":1,"b":2,"c":3}
dic_13=dic_12.copy() #{'a': 1, 'b': 2, 'c': 3}
print(dic_13)
"""六、字典推导式
可以从任何以键值对作为元素的可迭代对象中构建出字典"""
#例子1 给定一个字典对象{'a': 1, 'b': 2, 'c': 3}，找出其中所有大于 1 的键值对，同时 value 值进行平方运算
dic_11={k:v for k,v in[("a","b","c"),(1,2,3)]}
print(dic_11)
#例子2 将大于1的值平方返回一个新字典
dic_12={"a":1,"b":2,"c":3}
dic_13={k:v**2 for k,v in dic_12.items() if v>1}
print(dic_13) #{'b': 4, 'c': 9}
#例子3 将键换成值
dic_14={"a":1,"b":2,"c":3}
dic_15={v:k for k,v in dic_14.items()}
print(dic_15) #{1: 'a', 2: 'b', 3: 'c'}
十一、python 函数
"""一、函数的作用
函数是组织好的，可重复使用的，用来实现单一或者相关联功能的代码段
函数能提高应用的模块性和代码的重复利用率
python内置函数：https://docs.python.org/zh-cn/3.8/library/functions.html"""
"""二、函数的定义
def:函数关键字
function_name:函数名称
parameter_list:可选，指定向函数的参数
def function_name([parameter_list]):
['''xxx''']
[function_body]
注意缩进：python通过严格的缩进来判断代码块
函数体和注释相对def关键字保持一定的缩进，一般4个空格"""
def fun_a(a,b,c):
"""这是一个函数"""
print(f"传入的参数为{a}{b}{c}")
#打印函数comments内容
print(fun_a.__doc__) #这是一个函数
help(fun_a)
#定义空函数
#1、comments
def fun_demo1():
"""这是一个函数"""
#2、pass占位
def fun_demo2():
pass
"""三、函数调用"""
#无参数
def fun_demo3():
"""函数"""
print("这是函数")
fun_demo3() #这是函数
#有参数
def fun_demo4(a,b,c):
"""这是一个函数"""
print(f"传入的参数为{a}{b}{c}")
fun_demo4(1,2,3) #传入的参数为123
"""四、函数传递
形式参数：定义函数时，函数名称后面括号中的参数 abc
实际参数：调用函数时，函数名称后面括号中的参数 123"""
"""五、位置函数
数量必须与定义一致
位置必须与定义一致"""
#1、错误例子-数量错误
fun_demo4(1,2) #TypeError: fun_demo4() missing 1 required positional argument: 'c'
fun_demo4(1,2,3,4) #TypeError: fun_demo4() takes 3 positional arguments but 4 were given
#2、错误例子-位置传错
def person(name,age):
print(f"姓名为：{name}")
if age>=18:
print(f"{name}已成年")
person(20,"yanfa") #TypeError: '>=' not supported between instances of 'str' and 'int'
person("yanfa",20) #姓名为：yanfa yanfa已成年
"""六、关键字参数
使用形式参数的名字确定输入的参数值
不需要与形式参数的位置完全一致"""
def fun_demo4(a,b,c):
"""这是一个函数"""
print(f"传入的参数为{a}{b}{c}")
fun_demo4(a=1,c=3,b=2) #传入的参数为123
"""七、为参数设置默认值
定义函数时可以指定形式参数的默认值,需要是不可变对象如数字/字符串/元祖，否则默认值会随着调用发生变化
指定默认值的形式参数必须放在所有参数的最后，否则会产生语法错误
param=default_value:可选，指定参数并且为该函数设置默认值为default_value
def function_name(...,[param=default_value]
[function_body]"""
#1、不传参数
def fun_1(b=0):
print(f"传入参数为：{b}")
fun_1() #传入参数为：0
#2、错误示例-默认值不放最后
def fun_2(a,b=1,c):
print(f"传入参数为：{b}")
#3、错误示例，默认值为空列表
#需要是不可变对象如数字/字符串/元祖，否则默认值会随着调用发生变化
def fun_3(a,b,c=[]):
c.append(a)
c.append(b)
print(f"传入参数为：{a} {b} {c}")
fun_3(1,2) #传入参数为：1 2 [1, 2]
fun_3(3,4) #传入参数为：3 4 [1, 2, 3, 4]
"""函数返回值
return [value]
"""
#1、不传值则返回None
def sum(a,b):
result=a+b
return
res=sum(1,2)
print(res) #None
#2、返回一个值
def sum(a,b):
result=a+b
return result
res=sum(1,2)
print(res) #3
#3、返回多个值，用逗号分隔，作为元祖
def sum(a,b):
result=a+b
return result,a,b
res=sum(1,2)
print(res) #(3, 1, 2)
print(type(res)) #<class 'tuple'>
十二、python 函数进阶与参数处理
# @remark: 函数进阶与参数处理
""""""
"""一、可变参数
可变参数也称为不定长参数
传入参数中实际参数可以是任意多个
常用形式：*args **kwargs"""
"""*args
接受任意多个实际参数，并将其放入一个元祖中
使用已经存在的列表或元祖作为函数的可变参数，可以在列表名称前加*
传参是*是组合参数为元祖
调用时*是解包"""
def print_language(*args):
print(args)
#1、调用函数，把不同数量的参数传递进去，用位置函数
print_language("python","go") #存放到一个元祖('python', 'go')
print_language("python","go","java","php") #('python', 'go', 'java', 'php')
#2、等价为print_language("python","go","java","php")
lan=["python","go","java","php"]
# print_language(lan)
print_language(*lan) #('python', 'go', 'java', 'php')
"""**kwargs
接受任意多个类似关键字参数一样显示赋值的实际参数，并将其放到一个字典中
使用已经存在字典作为函数的可变参数，可以在字典的名称前面加**
**-打包的作用
调用时参数前面**表示解包"""
#1、打包
def print_info(**kwargs):
print(kwargs)
print_info(a=18,b=20) #{'a': 18, 'b': 20}
#2、解包 等价于print_info(a=18,b=20)
params={"a":18,"b":20}
print_info(**params) #解包 {'a': 18, 'b': 20}
十三、python lambda表达式
# @remark:匿名函数 lambda
""""""
import math
"""一、匿名函数
没有名字的函数
用lambda表达式创建匿名函数"""
"""二、使用场景
需要一个函数，但是又不想费神去命名这个函数
通常在这个函数只使用一次的场景下
可以指定短小的回调函数"""
"""三、语法
result:调用lambda表达式
[arg1[,arg2,...,argn]]：可选，指定要传递的参数列表
expression：必选，指定一个实现具体功能的表达式
result=lambda[arg1[,arg2,...,argn]]:expression"""
#1、实例-求圆面积
#常规写法
# def area(r):
# '''计算园面积 r-半径'''
# result=math.pi*r*r
# return result
# print(area(10))
#lambda表达式
r=10
result=lambda r:math.pi*r*r
print(result(r)) #314.1592653589793
#不可省略自己的变量，异常-如果不指定r
result=lambda r:math.pi*r*r
print(result) #<function <lambda> at 0x103ee9d30>
#示例2：对获取到的信息进行排序
book_info=[("python入门",22.5),("java入门",20),("测试入门",25)]
print(book_info) #
# 指定规则排序 lambda x:(x[1])-返回列表中每个元祖的第二个元素
book_info.sort(key=lambda x:(x[1]))
print(book_info) #[('java入门', 20), ('python入门', 22.5), ('测试入门', 25)]
十四、python 面向对象概念
# @remark:面向对象概念
""""""
"""一、面向对象是什么
python是一门面向对象的语言
面向对象编程oop：object oriented Programming
所谓的面向对象，就是在编程的时候尽可能的去模拟真实的现实世界，按照现实世界中的逻辑去处理问题
，分析问题中参与其中的有哪些实体，这些实体应该有什么属性和方法，我们如何通过调用这些实体的
属性和方法去解决问题。
"""
"""二、两种编程思想
面向过程：
一种以过程为中心的编程思想
首先分析解决问题所需要的步骤
然后用函数将这些步骤一步一步的实现
最后按顺序依次调用执行
面向对象：
是一种更符合我们人类思维习惯的编程思想
面向对象开发是不断创建对象，使用对象，操作对象做事
可以将复杂的事情简单化"""
"""三、类与对象
类：class 用来描述具有相同属性和方法的对象的集合。它定义了集合中每个对象共有的属性和方法
对象：object 也成为示例，是一个具体存在的实体 静态-属性（头发） 动态-行为（吃饭）"""
十五、python 类和对象
# @remark:类与对象
""""""
"""一、类的定义
class 关键字
class 类名(父类名):
'''类的帮组信息'''
属性：类中方法外定义的变量，名称或形容词，实例的状态或者数据
方法：类体中定义的函数，与函数一致，可以有参数列表和返回值。动词
"""
#1、实例
#类的声明 不传则默认父类是超类object
class Human:
"""人类"""
#定义属性（类属性）
message="这是类属性"
#构造方法 -自动执行,直接返回该类的实例，如果不行则默认创建一个构造方法
def __init__(self,name,age):
# 实例属性(变量)
self.name=name #通过self绑定到自身
self.age=age
print("这是构造方法")
print(Human.message) #这是类属性
"""二、类的方法
1）实例方法
-构造方法
2）类方法
3）静态方法"""
"""三、构造方法与实例化
作用：实例化对象
语法：def __init__(self,参数列表）
访问：类名(参数列表)"""
#实例化对象
person=Human("yanfa",18) #这是构造方法
#通过实例访问类属性
print(person.message) #这是类属性
#通过实例访问实例属性
print(person.name) #yanfa
print(person.age) #18
"""四、实例方法
作用：提供每个类的实例共享的方法
语法：def 方法名(self,参数列表）
访问：实例.方法名(参数列表)"""
# @remark:实例方法
class Human:
# 实例方法
def study(self,course):
print(f"正在学习{course}")
person=Human()
person.study("python") #正在学习python
"""五、类方法
作用：可以操作类的详细信息，不需要实例化
语法：@classmethod
访问：类名.类方法名(参数列表)"""
# @remark:类方法
class Human:
# 类属性
pop = 0
# 类方法 可以操作类的详细信息
@classmethod # 只能用这个装饰器
def born(cls): # cls是class的简写,是指类名本身
print("这是类方法")
cls.pop += 1
# 通过类名访问类方法
Human.born() # 这是类方法
print(Human.pop) # 1
"""六、静态方法
作用：不需要实例化对象
语法：@staticmethod
访问：类名.静态方法名()"""
# @remark:静态方法
class Human:
# 定义静态方法
@staticmethod
def grow_up():
print("这是静态方法")
#访问静态方法
Human.grow_up() #这是静态方法