admin管理员组

文章数量:1026989

第三章、第四章

                                    # 第三章python基础

# 字符串

## 概念

字符串：由0个或多个字符组成的有序字符序列

字符串由一对单引号或一对双引号表示

字符串是字符的有序序列，可以对其中的字符进行索引

# 基本数据类型

                                       数据类型

数据类型	示例	数据类型	示例
整型	100	列表	['abcd,786,2.23,70.2]
浮点型	12.3	元组	('abcd,786,2.23,70.2)
布尔型	True  False	字典	{'name':'fctet','site':'www.fciet'}
复数型	4+3j	集合	{'tom','jim','mary','jack','rose'}
字符串型	"hello"	"hello"

                                          转义符对照表

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\'	单引号
\\"	双引号
\b	退格
\000	空
\n	换行
\r	回车

%s：表示字符串

%d：表示整数

%f：表示浮点数

.format()方法用来实现字符串的格式化

#python运算符

 

 

 

# List

## 概念

列表是序列类型的一种扩展，十分常用

      列表是一种序列类型，创建后可以随意被修改

## 创建

• 使用方括号 [] 或list() 创建，元素间用逗号 , 分隔
• 列表中各元素类型可以不同，无长度限制

•list01 = [1,2,3,4]
•"""
•  [] 空列表
•  list() 里面什么都没有，创建空列表
•  list(["张三","李四"])
•"""
•list02 = list() #[]
•list03 = list(["张三","李四"])
•print(list01)
•print(list02)
•print(list03)
•list04 = [12.3,10,3.14e2,"张三"]
•print(list04) #[12.3, 10, 314.0, '张三']

#常用函数

#创建list
list01 = [1,2,5,7,-2,-9]#len(列表) 统计列表中元素的个数
a = len(list01)
print(a) #6#sum(列表) 求和
b = sum(list01)
print(b) #4#max(列表) 最大值
c= max(list01)
print(c) #7
#min(列表) 最小值
d = min(list01)
print(d) #9

# 增

#创建
list01 = ["cc","aa","dd","ss"]#list.insert(index,值)  根据下标进行插入数据
list01.insert(1,"aa")
print(list01)  #list.append(值) 在末尾插入
list01.append("dd")
print(list01) 

# 删

list01 = ["cc","aa","bb","ss"]#list.pop(index) 删除指定位置的数据
list01.pop(3)
print(list01)  #list.remove(值) 删除值，但是他删除的是值第一次出现的位置
list01.remove("cc")
print(list01) #list.clear() 删除所有数据
list01.clear()
print(list01) #[]

# 改

 List[i] = 值（要修改的值）

list01[3] = "ww"
print(list01) 

# 查 

#创建list
list01 = [1,2,5,7,-2,-9]#查询所有 ---直接打印列表名字
print(list01)

 ### 查询单个值

  利用[index]进行查询 index-->从0开始

print(list01[1])  #2

### 查询多个值

   [start:stop]   左开右闭

   小数在前面

   正向递增  反向递减   一负一正

"""
-6 -5 -4 -3  -2  -1[1  2  5  7  -2  -9]0  1  2  3   4   5
"""
print(list01[1:4])  #[2, 5, 7]
print(list01[-5:-2]) #[2, 5, 7]
print(list01[-5:4]) #[2, 5, 7]

# 常用方法

#list.reverse()   反转
list01 = [1,2,3,4,5,6]
list01.reverse()
print(list01)  #[6, 5, 4, 3, 2, 1]#list.copy() 拷贝
list02 = list01.copy()
print(list02)

list.sort(reverse = Ture/False) 排序 默认是升序

 reverse = Ture降序  reverse = False 升序

list03 = [1,8,4,2,-9]
list03.sort()
print(list03) #[-9, 1, 2, 4, 8]
list03.sort(reverse=True)
print(list03)  #[8, 4, 2, 1, -9]

 # 元组

概念

元组是序列类型的一种扩展

• 元组是一种序列类型，一旦创建就不能被修改  不能增删改

创建

• 使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔

  •#创建
  •tuple01 = (1,2,3)
  •tuple02 = tuple() #空元组  ()
  •tuple03 = tuple((5,6,7))
  •print(tuple01)
  •print(tuple02)
  •print(tuple03)

  ## 意义

•#创建
•tuple02 = tuple() #空元组  ()
•list01 = list() #[]
•"""
• 空列表  空元组  空集合 空字典都是False
• all()
•"""
•print(all([[],()])) #False

# 查

查询所有值  直接打印元组名字

 查询单个值  [index]

 查询多个值  [start:stop] 左开右闭 一负一正 

tuple02 = (1,2,3,4,5,6)
"""
-6  -5  -4  -3  -2  -1(1,  2,  3,  4,  5,  6)0    1   2  3   4   5
"""
print(tuple02)
print(tuple02[2])
print(tuple02[1:4])
print(tuple02[-5:-2])
print(tuple02[-5:4])

# 运算符

#创建
Str = ("张三")
print(type(Str)) #<class 'str'>
#字符串只能存放一个值  元组可以存放多个值，加个逗号可以进行区分
tuple01 = ("张三",)
print(type(tuple01)) #<class 'tuple'>
#复制完以后把数据变成元组
print(tuple01*3)  #('张三', '张三', '张三')

 

 # 字典

•  映射是一种键(索引)和值(数据)的对应

创建

• 键值对：键是数据索引的扩展
• 字典是键值对的集合，键值对之间无序(没有索引）
• 采用大括号{}和dict()创建，键值对用冒号: 表示
• 字典类型是“映射”的体现
• <字典变量> = {<键1>:<值1>, … , <键n>:<值n>

#创建
dict01 = {"张三":18,"李四":20,"王五":80}
dict02 = dict()
dict03 = dict({"张三":90,"李四":20})
print(dict01)  #{'张三': 18, '李四': 20, '王': 80}
print(dict02) #{}
print(dict03)  #{'张三': 90, '李四': 20}

# 增

dict01[新的key] = 新的值  添加数据

dict01["aa"] = "天魔缭乱"
print(dict01)

# 删

dict.pop(key)  根据key删除一对数据

 dict.clear()  清除所有数据

dict01.pop("ff")
print(dict01)

# 改

只能修改值，不可以修改key

  为什么：因为key是唯一的，不能重复的，避免出现重复的情况所以不能修改

  怎么修改： 

      先根据key拿到值  dict01["孙策"]

      再重新赋值

dict01["ss"] = "乘风破浪"
print(dict01) 

# 查

dict01 = {"aa":"空中支援","ss":"切换形态","dd":"开船","ff":"无敌时间移位"}# dict.keys()  查看所有的key(英雄)
print(dict01.keys()) #dict_keys(['aa', 'ss', 'dd', 'ff'])# dict.values()  查询所有的value(大招)
print(dict01.values())

查询单个值

  1.dict[key]  利用key查询value

  2.dict.get(key,默认值)  利用key查询value 如果key没有，那么就输出默认值

print(dict01["aa"]) #切换形态
print(dict01.get("aa"))  #切换形态
print(dict01.get("ee","没有此英雄，请购买"))

查询所有值(包括key和value)

  1.直接打印字典名

  2.dict.items() 迭代方法

print(dict01)

## 常用的函数和方法

k in dict    key在不在字典里面

 如果在输出True  如果不在输出False

 为什么 20 in dict0

 原因是他只能判断key在不在，不能判断value在不在

print("张三" in dict01) #True
print(20 in dict01) #False

"""dict01.update(dict02)  把02中的数据更新到01中更新是更新多个数据是复制吗？ no但是你可以理解成添加数据
"""
#创建字典
dict01 = {"张三":20,"王五":30,"赵六":70,"李四":80}
dict02 = {"翠花":20,"光头强":10}
dict01.update(dict02)
print(dict01) #{'张三': 20, '王五': 30, '赵六': 70, '李四': 80, '翠花': 20, '光头强': 10}
print(dict02) #{'翠花': 20, '光头强': 10}

 

#创建字典
dict01 = {"张三":20,"王五":30,"赵六":70,"李四":80}
dict02 = {"翠花":20,"光头强":10}

del 字典名[key]  删除指定位置的数据

  和pop一样 

  dict.pop(key) 删除指定位置的数据

del dict01["李四"]
print(dict01) #{'张三': 20, '王五': 30, '赵六': 70}

 # set 

概念

集合是多个元素的无序(没有下标)组合

集合类型与数学中的集合概念一致

集合元素之间无序，每个元素唯一，不存在相同元素

集合元素不可更改，不能是可变数据类型    

为什么？ 无序唯一

数据重复，会自动去重

## 创建

• 集合用大括号 {} 表示，元素间用逗号分隔
• 建立集合类型用 {} 或 set()
• 建立空集合类型，必须使用set()

•#创建
•set01 = {1,2,3,4,5}
•set02 = set() #set()
•set03 = set({9,10,11})
•print(set01)
•print(set02) 
•print(set03)

• 空列表 []
•  空元组 ()
•  空字典 {}
•  空集合 set()
•   原因是字典的创建也是{}，两者冲突了
•   所以我们的空集合是set(),创建空集合的时候必须使用set()

•print(type({})) #<class 'dict'>
•print(type(set())) #<class 'set'>

#增

#创建
set01 = {"花木兰","貂蝉","妲己","王昭君"}"""set.add(数据) 添加一个数据  也能添加已有的数据，
虽然不报错，但是不显示
"""
set01.add("杨玉环")
print(set01) #{'花木兰', '王昭君', '貂蝉', '妲己', '杨玉环'}
set01.add("花木兰")
print(set01) #{'花木兰', '杨玉环', '王昭君', '妲己', '貂蝉'}"""set01.update(set02) 批量添加数据把set02添加到zet01中
"""
set02 = {"嬴政","武则天"}
set01.update(set02)
print(set01) #{'花木兰', '嬴政', '杨玉环', '妲己', '王昭君', '武则天', '貂蝉'}

 # 删

#创建
set01 = {"喜羊羊","美羊羊","懒洋洋","沸羊羊","暖羊羊","慢羊羊","灰太狼"}"""set.discard(值)  删除集合中的值 如果数据不存在，不报错
""" 
set01.discard("美羊羊")
print(set01) #{'慢羊羊', '喜羊羊', '灰太狼', '暖羊羊', '懒洋洋', '沸羊羊'}
set01.discard("小灰灰")
print(set01)"""set.remove(值) 删除集合中的值 KeyError: '小灰灰'如果没有这个值，会报错
"""
set01.remove("慢羊羊")
print(set01) #{'懒洋洋', '灰太狼', '沸羊羊', '喜羊羊', '暖羊羊'}
#set01.remove("小灰灰")
#print(set01)"""set.pop() 随机删除
"""
set01.pop()   #{'懒洋洋', '沸羊羊', '喜羊羊', '暖羊羊'}#{'灰太狼', '喜羊羊', '沸羊羊', '暖羊羊'}
print(set01)# set.clear() 清空

# 改

 不可以更改数据

集合元素不可更改，不能是可变数据类型    

为什么？ 无序唯一

# 查

直接打印集合名字去查询

不能使用索引进行查询，因为我们集合是无序的

# 集合常用函数和方法

#创建
set01 = {"喜羊羊","美羊羊","懒洋洋","沸羊羊","暖羊羊","慢羊羊","灰太狼"}#set.copy() 复制/拷贝一个一模一样的集合
set02 = set01.copy()
print(set02) #{'慢羊羊', '美羊羊', '灰太狼', '喜羊羊', '沸羊羊', '暖羊羊', '懒洋洋'}#len(set) 返回集合的元素个数，集合的长度
a = len(set01)
print(a) #7"""x in set 元素x在不在集合当中x not in set 元素不在集合中
"""
print("慢羊羊" in set01) #True
print("慢羊羊" not in set01) #False#set(x) 把其他数据类型（x）转换成集合类型 
Str = "hello"
print(Str) #hello
print(type(Str))b = set(Str)
print(type(b)) #<class 'set'>
print(b) #{'o', 'e', 'h', 'l'}

# 并

"""并1.他的符号是  |2.返回两个集合的所有值
"""
print(set01 | set02) #{1,2,3,4,5,7,9}

# 差

"""差1.差的符号是  -2.set01 - set02  set01去掉公共部分的值
"""
print(set01 - set02) #{1, 4}
print(set02 - set01) #{9, 7}

# 交

"""交1.交的符号  &2.两个的公共部分
"""
print(set01 & set02)  #{2, 3, 5}

# 补

"""补集1.补集的符号 ^2.并集-交集 = 补集3.除去公共部分，set01和set02的单独部分我都要
"""
print(set01 ^ set02) #{1, 4, 7, 9}

# 包含关系

"""判断set01 和 set02是不是包含关系>  <   >=  <=口朝向那边，那边是大的set01 >= set02   set01包含set02
"""
print(set01 >= set02) #True
print(set01 < set02) #Falseprint(set02 < set01) #True

# 增强符

 S  |= t ---à s=s | t

编程语言的函数都可以分为两类：内置函数和自定义函数。

# 内置函数分为

## 数字相关的内置函数

# abs(x) 求绝对值
print(abs(-10))  #10"""divmod(x,y)  (x//y)商和(x%y)余数，同时输出商和余数x//y  整除  向下取整x%y  余数=被除数-除数*商  10%-3=-2
"""
x = 10
y = 3
print(divmod(10,3)) #(3, 1)"""pow(x,y) 幂 x的y次方 -------x**ypow(x,y,z) 先求x的y次方  得到的结果和z进行取余----x**y%z
"""
print(pow(x,y)) #1000
print(pow(x,y,3)) #1
print(pow(2,5,10)) #2**5 = 32  32%10=2

#round(x,f) 四舍五入保留小数
print(round(3.1415926,4))  #3.1416#max(x1,x2,..........,xn) 返回最大值
print(max(4,6,9,1,0,10)) #10

"""int(x) 将x转换成整数，舍弃小数部分可以把字符串转成整数,但是你的字符串必须是数字字符串 比如"123"
"""
print(int(3.92)) #3
print(int("123")) #123
#print(int("hello"))"""float(x) 将x转换成小数，增加小数部分可以把字符串变成小数,但是字符串必须是数字字符串 比如"123" "22.9"
"""
print(float(12)) #12.0
print(float("22")) #22.0
#print(float("hello"))
"""complex(x) 将x变成复数，增加虚数部分x可以是整数 、小数、数字类型的字符串
"""
print(complex(10)) #(10+0j)
print(complex(3.14)) #(3.14+0j)
print(complex("4.56")) #(4.56+0j)
#complex("hello")•进制的转换：bin()，oct()和hex()函数
"""
•进制的转换：bin() 转换成二进制(0b) 返回一个字符串oct() 转换成八进制(0o)  返回一个字符串hex() 转换成十六进制(0x) 返回一个字符串
"""
a = bin(100)
print(a) #0b1100100
print(type(a)) #<class 'str'>ASCII码与字符的转换：∞
"""chr(x) 把十进制转换成ASCLL编码字符ord(x) 把ASCLL编码字符转换成十进制
"""
print(ord("∞")) #8734
print(chr(64)) #@

## 序列相关的内置函数

"""all(序列)  all()接受一个序列 当序列中所有的元素都计算为真时，返回True，否则为False[]  ()  {}  set()都是Flase
All(“张三”,12.5,3e10,())
"""
a = ["hello",3.14,4+3j,{"张三":18,"李四":20}]
print(all(a)) #True
b = ["hello",3.14,4+3j,{"张三":18,"李四":20},[]]
print(all(b)) #False"""any(x)  any()则在序列中的任意一个元素为真时返回True，否则为False
Any(“张三”,[],(),{})"""
c = [{},(),set()]
print(any(c)) #False"""range(start,stop,step)  返回一个迭代对象左开右闭 迭代对象（需要list转换才能输出）start:开始数值stop:结束数值step:步长,和间隔不一样1.省略开始数值,开始数值会被默认成02.不能省略结束数值3.步长可以省略，如果步长不写，默认是1步长是2，间隔是1步长是3，间隔是2
"""
a = range(10)
print(a) #range(0, 10)
print(list(a)) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]c = range(1,10,2)
print(list(c)) #[1, 3, 5, 7, 9]
d = range(1,10,3)
print(list(d)) #[1, 4, 7]

Sorted(x) 排序，升序排序

Reversed(x)  反序，

List.sort(reverse = Ture)

"""sorted(x) 升序排序 返回一个新的序列
"""
a = [1,7,3,5,8,2]
print(sorted(a)) #[1, 2, 3, 5, 7, 8]
"""reversed(x) 反序排序 返回迭代器
"""
b = reversed(a)
print(list(b)) #[2, 8, 5, 3, 7, 1]c = [1,2,3,4,5,6]
print(reversed(c)) #<list_reverseiterator object at 0x0000026D0B74C7C8>
"""slice(start,stop,step)  切片，返回一个切片对象左开右闭  返回一个切片对象start:开始数值stop：结束数值step：步长1.步长可以省略，默认是1
"""
a = slice(5,15)
print(a) #slice(5, 15, None)
#把a换成一个迭代对象
b = range(20)[a]
print(b) #range(5, 15)
print(list(b)) #[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

 enumerate(x)   可以迭代序号和值：返回一个迭代对象

"""enumerate(x)  输出序号（下标）和值返回值是一个枚举对象，利用for循环输出
"""
a = enumerate(['a','b','c','d','e'])
print(a) #<enumerate object at 0x000001FFA3DC3AE8>
for xiabiao,zhi in a:print(xiabiao,zhi)

类型相关的内置函数

"""int(x) 将x转换成整数，舍弃小数部分可以把字符串转成整数,但是你的字符串必须是数字字符串 比如"123"
"""
print(int(3.92)) #3
print(int("123")) #123
#print(int("hello"))"""float(x) 将x转换成小数，增加小数部分可以把字符串变成小数,但是字符串必须是数字字符串 比如"123" "22.9"
"""
print(float(12)) #12.0
print(float("22")) #22.0
#print(float("hello"))
"""complex(x) 将x变成复数，增加虚数部分x可以是整数 、小数、数字类型的字符串
"""
print(complex(10)) #(10+0j)
print(complex(3.14)) #(3.14+0j)
print(complex("4.56")) #(4.56+0j)
#complex("hello")"""isinstance(变量,类型)  类型判断,如果变量和类型一致是true，不一致是false变量：自定义变量类型：Str int float list stuple dict set[1,2,3,4] --list列表{"张三":18,"李四":20}----dict字典{1,2,3} ---set集合(1,2) --tuple元组
"""
a = [1,2,3,4]
print(isinstance(a,list)) #True
print(isinstance(a,int)) #False

 # 自定义函数

定义

• 使用关键字def引导；
• def后面是函数的名称，括号中是函数的参数，不同的参数用逗号“,”隔开，参数可以为空，但括号不能省略；
• 函数的代码块要缩进；
• 用一对"""包含的字符串作为函数的说明，用来解释函数的用途，可省略，在查看函数帮助时会显示；
• 使用关键字 return返回一个特定的值，如果省略，返回None。

def  函数名称(参数1，参数2):

       代码块

        return

调用

>>> def add(x,y):

sum01 = x+y

return sum01

>>> add(2,3)

5

参数

  参数可以是0个，也可以是多个

带默认值的参数

定义

  Y的默认值是10

 >>> def cheng(x,y=10):

c = x*y

return c

调用

1. 可以只传一个参数，那这个参数就是x，y是默认值10
2. 如果传入两个参数，那么默认值不起作用

 >>> cheng(2)

20

>>> cheng(2,5)

10

不定数目的参数

定义

1.  * 号代表这个参数是个不确定个数的参数
2. 多个参数要用for进行循环输出
3. 在for循环中进行累加

def add(x,*y):

total = x

for i in y:

     #累加

total += i

return total

调用

相当于x=1  y= 2,3,4,5,6,7,8,9

>>> add(1,2,3,4,5,6,7,8,9)

45

相当于x=1  y=2

>>> add(1,2)

3

返回值

 返回值只能是一个吗，可以是多个吗

 可以返回多个值，多个值之间用逗号隔开

定义

>>> def suanfa(x,y):

sum01 = x+y

cheng01 = x*y

jian01 = x-y

return sum01,cheng01,jian01

调用

>>> suanfa(6,2)

(8, 12, 4)

# 模块

"""import 模块名1,模块2  as 别名导入整个模块，包括模块里面的属性、变量、方法、函数from 模块 import 成员名 as 别名导入模块中的某一个成员，只能用成员包含的东西
"""
#导入系统模块和文件操作模块
"""
import sys,os  as s,os
#打印python的环境变量
print(s.path)
"""
#argv  系统中文件的信息，比如文件路径，文件名字
from sys import argv as ar
print(ar[0])  #d:/axc/Python/PythonTemp/count.py

                                # 第四章python进阶

# 判断语句if

    ## 单分支

语法：

 if 条件:

     代码块

 1.冒号必须是英文状态下

 2.必须要缩进

代码

"""eval(字符串)1.把字符串转换成int类型a = eval("10")print(a) #10print(type(a)) #<class 'int'>2.对字符串进行计算a = "3*2" print(a) #3*2b = eval(a)print(b) #6
"""
#input("请猜一个数字") ---Str
#eval() 把Str转换成int
guess  = eval(input("请猜一个数字"))
if guess ==99:print("恭喜你猜对了") #恭喜你猜对了

## 二分支

语法：

 if 条件:

     代码块

 else:

     代码块

代码

guess  = eval(input("请猜一个数字"))
if guess == 99:print("恭喜你猜对了")
else:print("谢谢惠顾")

## 多分支

语法：

 if 条件:

     代码块

 elif 条件:

     代码块

 elif 条件:

     代码块

  ........

  else:

      代码块

代码

score = eval(input("请输入一个成绩："))
if score >= 90:print("a")
elif 90 > score>=80:print("B")
elif 80 >score>=70:print("C")
elif 70>score>=60:print("D")
else:print("不及格")

## 三目运算符

 if的缩写

满足条件的代码块  if 条件 else 不满足条件的代码块

print("恭喜你，猜对了")if guess == 99 else print("谢谢惠顾")

注意

1. 必须是二分支语句

条件判断以及组合

操作符	数学符号	描述
<	<	小于
<=	≤	小于等于
>=	≥	大于等于
>	>	大于
==	=	等于
！=	≠	不等于

操作符及使用	描述
x and y	两个条件x和y的逻辑与
x or y	两个条件x和y的逻辑或
not x	条件x的逻辑非

# 循环语句for

语法

for 变量 in 遍历结构:

     代码块

Set集合遍历

set01 = {1,2,3,4}
for i in set01:print(i)

无限循环(while)

语法：

a = 10
while a>0:a -= 1print(a)for i in [1,2,3,4,5]:if i == 2:breakprint(i)for i in [1,2,3,4,5]:if i == 2:continueprint(i)n = 100
print(n)if n%2==0 else print(n+1) #100

 while 条件:

     变量改变公式

     代码块

代码

a = 10
while a>0:#变量不断改变，为了满足条件，避免进入死循环a -= 1print(a)

# break continue

break跳出并结束当前整个循环，不执行循环后的语句

continue结束当次循环，继续执行后续次数循环

代码

for i in [1,2,3,4,5]:if i==2:breakprint(i) #1for i in [1,2,3,4,5]:if i==2:continueprint(i) #1

循环加else

语法

for  变量 in 遍历结构:

      代码块

  else:

      代码块  

执行流程

 1.先执行完for循环

 2.执行完以后执行else

代码

for i in [1,2,3,4,5]:print(i)
else:print("循环结束")

同理，while能不能加else，可以，和上面一样

while语法

while <条件> : 

    <语句块1>

else : 

    <语句块2>

#循环结束后，会执行else的代码

# 函数进阶

## 参数传递

参数传递机制

函数参数传递机制和赋值机制是一样的，其本质就是传递内存地址，这就是引用传递

 a传进来的时候传进来的是内存地址

 如果实在不理解，你可以以为是  x= a

def isid(x):#打印参数的内存地址print(id(x))a = 10
#变量的内存地址
print(id(a)) #140731588047408#a变成的参数，打印参数内存地址
isid(a) #140731588047408默认参数
#定义一个带有默认参数的函数
def add(x,y=10):sum01 = x+yreturn sum01"""
1.add(2)  x=2  y=10
2.add(2,3)  x=2  y=3
"""
print(add(2)) #12
print(add(2,3)) #5"""能不能传参传入一个序列类型，比如list，让他默认是[]
"""
def add(list01 = []):list01.append(1)return list01#第一调用
print(add()) #[1]
#第二次调用
print(add()) #[1, 1]
#第三次调用 
print(add()) #[1, 1, 1]

不定数目的参数

一个 *

"""一个* ：代表的是可变参数（就是可以是多个值）
"""
def add(x,*y):sum01 = xfor i in y:sum01 += ireturn sum01print(add(1,2,3,4,5)) #15

两个*

"""**y代表可以使用任意  键值（字典）  作为参数**y就相当于字典类型
"""
def func_add(x,**y):sum01 = x#切记这里是字典的循环for k,v in y.items():print(k,v)#把v（值）进行和x相加sum01 += vreturn sum01"""调用
a=3,b=4,c=5 ----> {"a":3,"b":4,"c":5}
"""
print(func_add(1,a=3,b=4,c=5)) #13

name

1.执行本文件的时候，name==main

#打印name这个属性
#执行本文件的时候，打印的是main，__name__ == __main__
print("1、"+__name__) #1、__main__

2.在被import导入到别的文件的时候，name==文件名字

"""一个文件就是一个模块，导入模块，就相当于导入文件，可以直接写import  文件名字
"""
import 本文件 as bwj
#在其他类中运行导入的文件名字，__name__==文件名字
print(bwj.__name__) #本文件

# 高阶函数

定义

高阶函数是一个（ 以函数为参数，或者以函数为返回值的）函数

函数可以是参数，参数是变量，那么函数可以是变量吗

参数其实就是变量进行了赋值，函数能不能是变量

函数为变量（补充）

  函数为变量并不是高阶函数，只是和大家补充这个知识点

"""函数为变量
"""
#定义一个函数，传入一个参数，求这个参数的平方
def func_pf(x):return pow(x,2)#字典
#已知李四的年龄是5的平方，求李四的年龄
dict01 = {"张三":20,"李四":func_pf}"""调用1.func_pf = dict01["李四"]  根据key获取value,vaule是一个函数对象2.age02 = func_pf(5) #调用函数就能获取年龄
"""
#字典的特点是根据key获取value
age01 = dict01["张三"]
print(age01) #20#顾名思义，通过李四，我们可以拿到函数func_pf
#拿到的是函数对象，我们不能直接打印
func_pf = dict01["李四"]
print(func_pf) #<function func_pf at 0x000001E25A23D048>age02 = func_pf(5)
print(age02) #25
#定义
#普通函数
def func_pf(x):return x**2#高阶函数，以函数为参数
def func_add(func_pf):#x**2+10return func_pf+10#2**2+10
a = func_add(func_pf(2))
print(a) #14

常用的高阶函数

这些常用的高阶函数是以函数为参数的高阶函数

map()

定义

 map(fun,x) 转换，接受一个序列，按照fun的函数逻辑转换成新的序列，返回一个map对象

1. x必须是一个序列
2. 返回一个map对象

代码

"""map(fun,x) 转换，接受一个序列，按照fun的函数逻辑转换成新的序列，返回一个map对象1. x必须是一个序列2.返回一个map对象
"""
def func_add(x):return x+1"""把原来的数据，经过func_add函数以后，每一个都加1，然后输出新的列表
"""
m = map(func_add,[1,2,3,4,5])
print(m) #<map object at 0x00000248E965C788>
print(list(m)) #[2, 3, 4, 5, 6]

filter()

定义

filter(func,x) 过滤，接受一个序列x，按照func函数要求进行转换, 

    func函数返回 True 或 False，最后将返回 True 的元素放到新列表中。

    返回filter对象

代码

"""
filter(func,x) 过滤，接受一个序列x，按照func函数要求进行转换, func函数返回 True 或 False，最后将返回 True 的元素放到新列表中。返回filter对象
"""
def func_ifScore(x):#比较运算符，本身就是返回布尔值的#如果大于等于60就是Ture，否则就是Falsereturn  x>=60f =  filter(func_ifScore,[80,98,70,34,60,59,10])
print(f)  #<filter object at 0x00000232CC78C808>
print(list(f)) #[80, 98, 70, 60]

reduce()

定义

 reduce(func,x) 计算，接受一个序列，把列表中的每一个值按照函数进行累加或者别的运算

   返回一个计算数值

   1.因为是计算，所以我们的func是两个参数

   2.必须要导包

代码

from functools import reduce
"""reduce(func,x) 计算，接受一个序列，把列表中的每一个值按照函数进行累加或者别的运算返回一个计算数值1.因为是计算，所以我们的func是两个参数2.必须要导包
"""
#累加   1+2+3+4+5
def func_add(x,y):return x+ya = reduce(func_add,[1,2,3,4,5])
print(a) #15

zip()

定义

 zip(list01,list02) 拉链、压缩

  用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，返回一个对象

  1.参数必须是可迭代的序列类型

  2.对象里面放的是一个一个的元组

  3.返回一个zip对象

代码

list01 = [1,3,5,7,9]
list02 = [2,4,6,8,10]z = zip(list01,list02)
print(z) #<zip object at 0x00000292EE17C7C8>
#print(list(z)) #[(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]"""数据不一样多了，拉链不一样长了，结果该怎么办呢以短的为基础
"""
list03 = [1,3,5,7,9,11,13]
list04 = [2,4,6]
a = zip(list03,list04)
#print(list(a)) #[(1, 2), (3, 4), (5, 6)]"""a是一个压缩、拉链数据，能不能解压呢，1.符号是*2.zip(*list类型)3.声明两个变量去承接4.zip对象如果执行过了，就不存在了
"""
b = list(a)
list05,list06 = zip(*b)
print(list05) #(1, 3, 5)
print(list06) #(2, 4, 6)

sorted()

定义

 sorted(序列类型的对象,key=函数,reverse=True/False)  排序

  1.reverse=True/False   升序是False 降序是Ture

代码

#list里面可以放任何数据类型
list01 = [{"name":"张三","age":20},{"name":"李四","age":30},{"name":"王五","age":18},{"name":"小明","age":8}]#按照年龄进行排序
#定义一个函数，返回一个年龄
def func_age(list01):#根据key（age）获取value（年龄）age01 = list01["age"]return age01s = sorted(list01,key=func_age,reverse=False)
print(s)
#[{'name': '小明', 'age': 8}, {'name': '王五', 'age': 18}, {'name': '张三', 'age': 20}, {'name': '李四', 'age': 30}]

偏函数（补充）

语法

 from functools import partial

  partial(fun,x)

   fun:你的函数

    x：你要固定的函数中参数

代码

#x的y次方
def func01(x,y):return x**y"""简化2上面的这种这能固定x，没办法固定y，使用偏函数解决这个bug偏函数1.partial(fun,你要固定的那个参数x)  可以固定函数中的任意一个参数2.导包 from functools import partialdef func01(x,y=2):return x**y
"""
from functools import partial
#func = func01(x,y=2)
func = partial(func01,y=2)
a =  func(3) #x=3
#a = x**2=3**2=9
print(a) #9#可以固定多个参数，可以把x和y都固定住
from functools import partial
#func = func01(x=10,y=2)
func = partial(func01,y=2,x=10)
a =  func() 
print(a) #100

lambda表达式

定义

lambda表达式是一行函数。在其他语言中叫做匿名函数

语法

 lambda 参数1,参数2,参数n : 逻辑

代码

"""lambda表达式：一行函数理解为函数的简写
"""def func01(x,y):return x**ylambda x,y:x**y

# 函数的递归

定义

 递归是指函数在执行过程中调用了本身。简单来说就是自己调用了自己

 1.自己调用自己

 2.一定要有一个条件，进行退出调用

代码

"""递归是指函数在执行过程中调用了本身。简单来说就是自己调用了自己1.自己调用自己2.一定要有一个条件，进行退出调用
"""
"""阶乘：比如说给一个数据5，阶乘5*4*3*2*1n = 5*(5-1)n =n*(4-1)n =n*(3-1) n =n*(2-1)总结规律n! = n*(n-1)
"""
def func_jc(n):if n==1:return 1else:return n*func_jc(n-1)print(func_jc(5)) #120

效率的比较

 我能用普通函数写出来，为什么非要学递归

import time
"""函数递归
"""
def func_fb(n):if n==0 or n==1:return 1else:return func_fb(n-2)+func_fb(n-1)"""非递归#下标是从0开始的
"""
def func(n):#初始化两个变量a,b=1,1#range(5) ---->0,1,2,3,4for i in range(n):a,b=b,a+breturn a#perf_counter 以秒为单位进行记时间
start01 = time.perf_counter()
func_fb(10)
stop01= time.perf_counter()
print("递归函数的调用时间 %s" %(stop01-start01))#process_time 以秒为单位进行记时间
start02 = time.perf_counter()
func(10)
stop02= time.perf_counter()
print("非递归函数的调用时间%s"%(stop02-start02))
"""
递归函数的调用时间 5.050000000000193e-05
非递归函数的调用时间7.3000000000017495e-06
"""

# 装饰器

定义

 1.装饰器是一个函数

 2.装饰器是一个 为函数添加新的属性  的函数

 3.通过闭包对函数添加新的属性

语法

 语法

 1.def func_a()  #带有新特新的闭包函数

   @def func_a

 2.def func_b()  #被修饰的函数

相当于func_a(func_b)

可以是多个@，如果是多个@的话，从下往上运行

代码1

"""1.装饰器是一个函数2.装饰器是一个 为函数添加新的属性  的函数3.通过闭包对函数添加新的属性
闭包函数:函数的子函数就是闭包函数
"""
#装饰器
def zhuangxiudui(a):#闭包函数def zhuangxiufangan():print("贴瓷砖")a()print("隔音棉")return zhuangxiufangan@zhuangxiudui
def qiang():print("来看看，就是这三面强")
#16-18行相当于  zhangxiudui(qiang)
#把qiang作为参数，传给了装修队这个函数@zhuangxiudui
def men():print("我是门")
"""22-24行代表  zhangxiudui(men)
"""#一周之后我来验货，来看看强弄好了没
qiang()
"""
贴瓷砖
来看看，就是这三面强
隔音棉
"""

代码2

#装饰器
def zhuangxiudui(a):#闭包函数def zhuangxiufangan():print("贴瓷砖")a()print("隔音棉")return zhuangxiufangandef gaojizhuangxidui(b):def zhuangxiufangan():#你现在的墙是由瓷砖由隔音棉b()print("拆除瓷砖")print("拆除隔音棉")print("刷粉漆")return zhuangxiufangan"""本来把墙给装修队，结果他装修坏了，我有找了一个高级装修队，进行重新装修gaojizhuangxiudui(zhuangxiudui(qiang))b=zhuangxiudui(qiang)a=qiang
"""
@gaojizhuangxidui
@zhuangxiudui
def qiang():print("来看看，就是这三面强")qiang()
"""
贴瓷砖
来看看，就是这三面强
隔音棉
拆除瓷砖
拆除隔音棉
刷粉漆
"""

Wraps()函数

定义

1. @wraps(gaoyuanyuan) 保留高圆圆这个函数的所有属性和方法

2. from functools import wraps

Wraps(被修饰的物体) 保留被修饰物体的属性和函数  

# 迭代器

定义

 迭代器是一个可以遍历容器的一个对象

1. 迭代器返回一个对象

2. 那些东西可以进行迭代

  容器类型的---list  set  字典 字符串

"""迭代器#注意是两个下划线list01.__iter__() 返回一个迭代器对象<list_iterator object at 0x0000024037E0C588>
"""
list01 = [1,2,3,4]
#注意是两个下划线
a =  list01.__iter__()
print(a) #<list_iterator object at 0x0000024037E0C588>
"""1.我听要他何用，他是一个对象，我想要的是值迭代器对象.__next__() 返回一个值2.他只能返回第一个值吗  no因为next()可以记忆位置，每次你调用一次，他会记住这位置，然后下一次从下一个位置开始3.我要是一直调用，可以吗报错StopIteration，没有数据了我们的next没有办法回头，不会从头开始，他只会从记忆的位置的开始
"""
print(a.__next__()) #1
print(a.__next__()) #2
print(a.__next__()) #3
print(a.__next__()) #4
print(a.__next__()) #报错

迭代

list01 = [1,2,3,4]
#注意是两个下划线
a =  list01.__iter__()
"""迭代对象的遍历1.__next__() 不会从头开始， 每次从记忆的位置开始2.for循环就相当于是不断的打印__next__()。但是为什么没报错自己抛出StopIteration，然后停止循环
"""
for i in list01:print(i)

迭代对象

1. 那些东西可以进行迭代

  容器类型的---list  set  字典 字符串

为什么是两个下划线

有些方法以双下划线 “__” 开头和结尾，它们是Python的魔法函数，用于特殊用途

Next()

.next()

.__Next__()

__init__()

__iter__()

Func_sum()

# 生成器

定义

生成器也是一种迭代器，但是你只能对其迭代一次。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个特殊的迭代器。

生成器可以一边循环一边计算

优点是节省内存

关键字是：yield

总结

1. 生成器都是迭代器，迭代器不一定是生成器

2. 字符串，列表，元组，字典，集合都可以被for循环，说明他们都是可迭代对象

3. 迭代器的两个方法：1.有__iter__() 2. 有__next__()

4. isinstance() 类型判断。isinstance(a,Iterable) 判断a 是否是可迭代对象。

# 推导式

推导式是从一个或者多个迭代器快速创建序列的一种方法。

语法

[逻辑/结果 for i in 序列类型的变量]

"""
普通循环
"""
for i in [1,2,3,4]:print(i)
"""
推导式
"""
[print(i) for i in [1,2,3,4]]

列表类型

"""推导式
"""
list01 = [1,2,3,4]
a=  [i+1 for i in list01]
print(a) #[2, 3, 4, 5]
print(type(a)) #<class 'list'>

元组类型

list01 = [1,2,3,4]
#把里面的代码看成一个整体，一个对象
#利用我们的tuple()函数
a=  tuple(i+1 for i in list01)
print(a)  #(2, 3, 4, 5)
print(type(a)) #<class 'tuple'>#把3+2变成一个整体
(3+2)/9

集合类型

list01 = [1,2,3,4]
a=  {i+1 for i in list01}
print(a) #{2, 3, 4, 5}
print(type(a)) #<class 'set'>

字典类型

dict01 = {"王五":20,"张三":50,"李四":80,"赵六":18}for k,v in dict01.items():print(k,v){print(k,v) for k,v in dict01.items()}

# 异常处理

语法

Try – except-else

"""try -except-elsetry:代码块except <错误的名字(可写可不写)>:代码块...........else:代码块
可以把else去掉
try:代码块except <错误的名字(可写可不写)>:代码块
注意：1.try不能单独使用2.错误的名字(可写可不写)
运行结果：报错(除数是0)，运行的是except不报错(除数不是0)，运行的是else
"""
try:s = eval(input("请输入一个数字："))a = 10/s
except ZeroDivisionError:print("除数不能是零")
else:print("除数是正常的，运行成功")

Try-finally

"""
Try-finallytry：代码块finally:代码块
执行结果：无论报不报错最终都会执行
"""
#control+ctry:s= input("请输入内容")
finally:print("异常退出")

Raise关键字

"""raise：无论代码是否异常，他自己会触发异常语法：raise 异常名称
"""
try:s = eval(input("请输入一个除数："))a = 10/s#无论你的除数等不等于0，他都会报错raise ZeroDivisionError
except ZeroDivisionError:#except是异常的时候给出的警告print("警告：除数不能为0")
"""
请输入一个除数：3
警告：除数不能为0
"""

常见的异常列表(要求再认)

BaseException	所有异常的基类
SystemExit	解释器请求退出
KeyboardInterrupt	用户中断执行(通常是输入^C)
Exception	常规错误的基类
StopIteration	迭代器没有更多的值
GeneratorExit	生成器(generator)发生异常来通知退出
StandardError	所有的内建标准异常的基类
ArithmeticError	所有数值计算错误的基类
FloatingPointError	浮点计算错误
ValueError	传入无效的参数
ZeroDivisionError	除(或取模)零 (所有数据类型)
KeyError	映射中没有这个键
AttributeError	对象没有这个属性

作用域

是按照变量的查找顺序 L>E>G>B

L(local) 局部作用域

"""
L(local) 局部作用域
"""
def func():#a是函数中的变量，是局部变量,只能在函数中使用a=10print(a)
#a是不存在的
print(a)E(Enclosing) 闭包函数中的作用域nonlocal  :把闭包外的变量引用过来
#刚出生的年龄，是全局变量，意味这谁都是从这个年龄开始的
age = 1
def qunian():#闭包外的变量，局部变量  4-11能用age = 19def jinian():"""#把全局变量引用过来，那么就是把age=1引用过来global age我们想要引用的是闭包外面的变量nonlocal  :把闭包外的变量引用过来"""nonlocal age#闭包里面的变量 ，局部变量 7-9行能用age=age +1print("今年的年龄",age)print("去年的年龄",age)return jinian#qunian()返回的是return jinian
jinian = qunian()
#所以还要调用一下今年这个函数jinian()
jinian()
#今年的年龄 20

# G(Global) 全局作用域

global  把全局的age引用过来

"""
G(Global) 全局作用域
"""
#全局
age = 20
def func():#把全局的age引用过来global age#局部#前面的a相当于是重新赋值的a，是局部的#后面的a是要进行相加的数据，所以要有这个数据，所以是全局的age=1 + agereturn ageprint(func()) #30

B(Built-in) 内建作用域

系统固定模块里面的变量，比如 int, bytearray 等。

比如函数名 abs、char 和异常名称 BaseException、Exception 等等。

总结

是按照变量的查找顺序 L>E>G>B

第三章、第四章

                                    # 第三章python基础

# 字符串

## 概念

字符串：由0个或多个字符组成的有序字符序列

字符串由一对单引号或一对双引号表示

字符串是字符的有序序列，可以对其中的字符进行索引

# 基本数据类型

                                       数据类型

数据类型	示例	数据类型	示例
整型	100	列表	['abcd,786,2.23,70.2]
浮点型	12.3	元组	('abcd,786,2.23,70.2)
布尔型	True  False	字典	{'name':'fctet','site':'www.fciet'}
复数型	4+3j	集合	{'tom','jim','mary','jack','rose'}
字符串型	"hello"	"hello"

                                          转义符对照表

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\'	单引号
\\"	双引号
\b	退格
\000	空
\n	换行
\r	回车

%s：表示字符串

%d：表示整数

%f：表示浮点数

.format()方法用来实现字符串的格式化

#python运算符

 

 

 

# List

## 概念

列表是序列类型的一种扩展，十分常用

      列表是一种序列类型，创建后可以随意被修改

## 创建

• 使用方括号 [] 或list() 创建，元素间用逗号 , 分隔
• 列表中各元素类型可以不同，无长度限制

•list01 = [1,2,3,4]
•"""
•  [] 空列表
•  list() 里面什么都没有，创建空列表
•  list(["张三","李四"])
•"""
•list02 = list() #[]
•list03 = list(["张三","李四"])
•print(list01)
•print(list02)
•print(list03)
•list04 = [12.3,10,3.14e2,"张三"]
•print(list04) #[12.3, 10, 314.0, '张三']

#常用函数

#创建list
list01 = [1,2,5,7,-2,-9]#len(列表) 统计列表中元素的个数
a = len(list01)
print(a) #6#sum(列表) 求和
b = sum(list01)
print(b) #4#max(列表) 最大值
c= max(list01)
print(c) #7
#min(列表) 最小值
d = min(list01)
print(d) #9

# 增

#创建
list01 = ["cc","aa","dd","ss"]#list.insert(index,值)  根据下标进行插入数据
list01.insert(1,"aa")
print(list01)  #list.append(值) 在末尾插入
list01.append("dd")
print(list01) 

# 删

list01 = ["cc","aa","bb","ss"]#list.pop(index) 删除指定位置的数据
list01.pop(3)
print(list01)  #list.remove(值) 删除值，但是他删除的是值第一次出现的位置
list01.remove("cc")
print(list01) #list.clear() 删除所有数据
list01.clear()
print(list01) #[]

# 改

 List[i] = 值（要修改的值）

list01[3] = "ww"
print(list01) 

# 查 

#创建list
list01 = [1,2,5,7,-2,-9]#查询所有 ---直接打印列表名字
print(list01)

 ### 查询单个值

  利用[index]进行查询 index-->从0开始

print(list01[1])  #2

### 查询多个值

   [start:stop]   左开右闭

   小数在前面

   正向递增  反向递减   一负一正

"""
-6 -5 -4 -3  -2  -1[1  2  5  7  -2  -9]0  1  2  3   4   5
"""
print(list01[1:4])  #[2, 5, 7]
print(list01[-5:-2]) #[2, 5, 7]
print(list01[-5:4]) #[2, 5, 7]

# 常用方法

#list.reverse()   反转
list01 = [1,2,3,4,5,6]
list01.reverse()
print(list01)  #[6, 5, 4, 3, 2, 1]#list.copy() 拷贝
list02 = list01.copy()
print(list02)

list.sort(reverse = Ture/False) 排序 默认是升序

 reverse = Ture降序  reverse = False 升序

list03 = [1,8,4,2,-9]
list03.sort()
print(list03) #[-9, 1, 2, 4, 8]
list03.sort(reverse=True)
print(list03)  #[8, 4, 2, 1, -9]

 # 元组

概念

元组是序列类型的一种扩展

• 元组是一种序列类型，一旦创建就不能被修改  不能增删改

创建

• 使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔

  •#创建
  •tuple01 = (1,2,3)
  •tuple02 = tuple() #空元组  ()
  •tuple03 = tuple((5,6,7))
  •print(tuple01)
  •print(tuple02)
  •print(tuple03)

  ## 意义

•#创建
•tuple02 = tuple() #空元组  ()
•list01 = list() #[]
•"""
• 空列表  空元组  空集合 空字典都是False
• all()
•"""
•print(all([[],()])) #False

# 查

查询所有值  直接打印元组名字

 查询单个值  [index]

 查询多个值  [start:stop] 左开右闭 一负一正 

tuple02 = (1,2,3,4,5,6)
"""
-6  -5  -4  -3  -2  -1(1,  2,  3,  4,  5,  6)0    1   2  3   4   5
"""
print(tuple02)
print(tuple02[2])
print(tuple02[1:4])
print(tuple02[-5:-2])
print(tuple02[-5:4])

# 运算符

#创建
Str = ("张三")
print(type(Str)) #<class 'str'>
#字符串只能存放一个值  元组可以存放多个值，加个逗号可以进行区分
tuple01 = ("张三",)
print(type(tuple01)) #<class 'tuple'>
#复制完以后把数据变成元组
print(tuple01*3)  #('张三', '张三', '张三')

 

 # 字典

•  映射是一种键(索引)和值(数据)的对应

创建

• 键值对：键是数据索引的扩展
• 字典是键值对的集合，键值对之间无序(没有索引）
• 采用大括号{}和dict()创建，键值对用冒号: 表示
• 字典类型是“映射”的体现
• <字典变量> = {<键1>:<值1>, … , <键n>:<值n>

#创建
dict01 = {"张三":18,"李四":20,"王五":80}
dict02 = dict()
dict03 = dict({"张三":90,"李四":20})
print(dict01)  #{'张三': 18, '李四': 20, '王': 80}
print(dict02) #{}
print(dict03)  #{'张三': 90, '李四': 20}

# 增

dict01[新的key] = 新的值  添加数据

dict01["aa"] = "天魔缭乱"
print(dict01)

# 删

dict.pop(key)  根据key删除一对数据

 dict.clear()  清除所有数据

dict01.pop("ff")
print(dict01)

# 改

只能修改值，不可以修改key

  为什么：因为key是唯一的，不能重复的，避免出现重复的情况所以不能修改

  怎么修改： 

      先根据key拿到值  dict01["孙策"]

      再重新赋值

dict01["ss"] = "乘风破浪"
print(dict01) 

# 查

dict01 = {"aa":"空中支援","ss":"切换形态","dd":"开船","ff":"无敌时间移位"}# dict.keys()  查看所有的key(英雄)
print(dict01.keys()) #dict_keys(['aa', 'ss', 'dd', 'ff'])# dict.values()  查询所有的value(大招)
print(dict01.values())

查询单个值

  1.dict[key]  利用key查询value

  2.dict.get(key,默认值)  利用key查询value 如果key没有，那么就输出默认值

print(dict01["aa"]) #切换形态
print(dict01.get("aa"))  #切换形态
print(dict01.get("ee","没有此英雄，请购买"))

查询所有值(包括key和value)

  1.直接打印字典名

  2.dict.items() 迭代方法

print(dict01)

## 常用的函数和方法

k in dict    key在不在字典里面

 如果在输出True  如果不在输出False

 为什么 20 in dict0

 原因是他只能判断key在不在，不能判断value在不在

print("张三" in dict01) #True
print(20 in dict01) #False

"""dict01.update(dict02)  把02中的数据更新到01中更新是更新多个数据是复制吗？ no但是你可以理解成添加数据
"""
#创建字典
dict01 = {"张三":20,"王五":30,"赵六":70,"李四":80}
dict02 = {"翠花":20,"光头强":10}
dict01.update(dict02)
print(dict01) #{'张三': 20, '王五': 30, '赵六': 70, '李四': 80, '翠花': 20, '光头强': 10}
print(dict02) #{'翠花': 20, '光头强': 10}

 

#创建字典
dict01 = {"张三":20,"王五":30,"赵六":70,"李四":80}
dict02 = {"翠花":20,"光头强":10}

del 字典名[key]  删除指定位置的数据

  和pop一样 

  dict.pop(key) 删除指定位置的数据

del dict01["李四"]
print(dict01) #{'张三': 20, '王五': 30, '赵六': 70}

 # set 

概念

集合是多个元素的无序(没有下标)组合

集合类型与数学中的集合概念一致

集合元素之间无序，每个元素唯一，不存在相同元素

集合元素不可更改，不能是可变数据类型    

为什么？ 无序唯一

数据重复，会自动去重

## 创建

• 集合用大括号 {} 表示，元素间用逗号分隔
• 建立集合类型用 {} 或 set()
• 建立空集合类型，必须使用set()

•#创建
•set01 = {1,2,3,4,5}
•set02 = set() #set()
•set03 = set({9,10,11})
•print(set01)
•print(set02) 
•print(set03)

• 空列表 []
•  空元组 ()
•  空字典 {}
•  空集合 set()
•   原因是字典的创建也是{}，两者冲突了
•   所以我们的空集合是set(),创建空集合的时候必须使用set()

•print(type({})) #<class 'dict'>
•print(type(set())) #<class 'set'>

#增

#创建
set01 = {"花木兰","貂蝉","妲己","王昭君"}"""set.add(数据) 添加一个数据  也能添加已有的数据，
虽然不报错，但是不显示
"""
set01.add("杨玉环")
print(set01) #{'花木兰', '王昭君', '貂蝉', '妲己', '杨玉环'}
set01.add("花木兰")
print(set01) #{'花木兰', '杨玉环', '王昭君', '妲己', '貂蝉'}"""set01.update(set02) 批量添加数据把set02添加到zet01中
"""
set02 = {"嬴政","武则天"}
set01.update(set02)
print(set01) #{'花木兰', '嬴政', '杨玉环', '妲己', '王昭君', '武则天', '貂蝉'}

 # 删

#创建
set01 = {"喜羊羊","美羊羊","懒洋洋","沸羊羊","暖羊羊","慢羊羊","灰太狼"}"""set.discard(值)  删除集合中的值 如果数据不存在，不报错
""" 
set01.discard("美羊羊")
print(set01) #{'慢羊羊', '喜羊羊', '灰太狼', '暖羊羊', '懒洋洋', '沸羊羊'}
set01.discard("小灰灰")
print(set01)"""set.remove(值) 删除集合中的值 KeyError: '小灰灰'如果没有这个值，会报错
"""
set01.remove("慢羊羊")
print(set01) #{'懒洋洋', '灰太狼', '沸羊羊', '喜羊羊', '暖羊羊'}
#set01.remove("小灰灰")
#print(set01)"""set.pop() 随机删除
"""
set01.pop()   #{'懒洋洋', '沸羊羊', '喜羊羊', '暖羊羊'}#{'灰太狼', '喜羊羊', '沸羊羊', '暖羊羊'}
print(set01)# set.clear() 清空

# 改

 不可以更改数据

集合元素不可更改，不能是可变数据类型    

为什么？ 无序唯一

# 查

直接打印集合名字去查询

不能使用索引进行查询，因为我们集合是无序的

# 集合常用函数和方法

#创建
set01 = {"喜羊羊","美羊羊","懒洋洋","沸羊羊","暖羊羊","慢羊羊","灰太狼"}#set.copy() 复制/拷贝一个一模一样的集合
set02 = set01.copy()
print(set02) #{'慢羊羊', '美羊羊', '灰太狼', '喜羊羊', '沸羊羊', '暖羊羊', '懒洋洋'}#len(set) 返回集合的元素个数，集合的长度
a = len(set01)
print(a) #7"""x in set 元素x在不在集合当中x not in set 元素不在集合中
"""
print("慢羊羊" in set01) #True
print("慢羊羊" not in set01) #False#set(x) 把其他数据类型（x）转换成集合类型 
Str = "hello"
print(Str) #hello
print(type(Str))b = set(Str)
print(type(b)) #<class 'set'>
print(b) #{'o', 'e', 'h', 'l'}

# 并

"""并1.他的符号是  |2.返回两个集合的所有值
"""
print(set01 | set02) #{1,2,3,4,5,7,9}

# 差

"""差1.差的符号是  -2.set01 - set02  set01去掉公共部分的值
"""
print(set01 - set02) #{1, 4}
print(set02 - set01) #{9, 7}

# 交

"""交1.交的符号  &2.两个的公共部分
"""
print(set01 & set02)  #{2, 3, 5}

# 补

"""补集1.补集的符号 ^2.并集-交集 = 补集3.除去公共部分，set01和set02的单独部分我都要
"""
print(set01 ^ set02) #{1, 4, 7, 9}

# 包含关系

"""判断set01 和 set02是不是包含关系>  <   >=  <=口朝向那边，那边是大的set01 >= set02   set01包含set02
"""
print(set01 >= set02) #True
print(set01 < set02) #Falseprint(set02 < set01) #True

# 增强符

 S  |= t ---à s=s | t

编程语言的函数都可以分为两类：内置函数和自定义函数。

# 内置函数分为

## 数字相关的内置函数

# abs(x) 求绝对值
print(abs(-10))  #10"""divmod(x,y)  (x//y)商和(x%y)余数，同时输出商和余数x//y  整除  向下取整x%y  余数=被除数-除数*商  10%-3=-2
"""
x = 10
y = 3
print(divmod(10,3)) #(3, 1)"""pow(x,y) 幂 x的y次方 -------x**ypow(x,y,z) 先求x的y次方  得到的结果和z进行取余----x**y%z
"""
print(pow(x,y)) #1000
print(pow(x,y,3)) #1
print(pow(2,5,10)) #2**5 = 32  32%10=2

#round(x,f) 四舍五入保留小数
print(round(3.1415926,4))  #3.1416#max(x1,x2,..........,xn) 返回最大值
print(max(4,6,9,1,0,10)) #10

"""int(x) 将x转换成整数，舍弃小数部分可以把字符串转成整数,但是你的字符串必须是数字字符串 比如"123"
"""
print(int(3.92)) #3
print(int("123")) #123
#print(int("hello"))"""float(x) 将x转换成小数，增加小数部分可以把字符串变成小数,但是字符串必须是数字字符串 比如"123" "22.9"
"""
print(float(12)) #12.0
print(float("22")) #22.0
#print(float("hello"))
"""complex(x) 将x变成复数，增加虚数部分x可以是整数 、小数、数字类型的字符串
"""
print(complex(10)) #(10+0j)
print(complex(3.14)) #(3.14+0j)
print(complex("4.56")) #(4.56+0j)
#complex("hello")•进制的转换：bin()，oct()和hex()函数
"""
•进制的转换：bin() 转换成二进制(0b) 返回一个字符串oct() 转换成八进制(0o)  返回一个字符串hex() 转换成十六进制(0x) 返回一个字符串
"""
a = bin(100)
print(a) #0b1100100
print(type(a)) #<class 'str'>ASCII码与字符的转换：∞
"""chr(x) 把十进制转换成ASCLL编码字符ord(x) 把ASCLL编码字符转换成十进制
"""
print(ord("∞")) #8734
print(chr(64)) #@

## 序列相关的内置函数

"""all(序列)  all()接受一个序列 当序列中所有的元素都计算为真时，返回True，否则为False[]  ()  {}  set()都是Flase
All(“张三”,12.5,3e10,())
"""
a = ["hello",3.14,4+3j,{"张三":18,"李四":20}]
print(all(a)) #True
b = ["hello",3.14,4+3j,{"张三":18,"李四":20},[]]
print(all(b)) #False"""any(x)  any()则在序列中的任意一个元素为真时返回True，否则为False
Any(“张三”,[],(),{})"""
c = [{},(),set()]
print(any(c)) #False"""range(start,stop,step)  返回一个迭代对象左开右闭 迭代对象（需要list转换才能输出）start:开始数值stop:结束数值step:步长,和间隔不一样1.省略开始数值,开始数值会被默认成02.不能省略结束数值3.步长可以省略，如果步长不写，默认是1步长是2，间隔是1步长是3，间隔是2
"""
a = range(10)
print(a) #range(0, 10)
print(list(a)) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]c = range(1,10,2)
print(list(c)) #[1, 3, 5, 7, 9]
d = range(1,10,3)
print(list(d)) #[1, 4, 7]

Sorted(x) 排序，升序排序

Reversed(x)  反序，

List.sort(reverse = Ture)

"""sorted(x) 升序排序 返回一个新的序列
"""
a = [1,7,3,5,8,2]
print(sorted(a)) #[1, 2, 3, 5, 7, 8]
"""reversed(x) 反序排序 返回迭代器
"""
b = reversed(a)
print(list(b)) #[2, 8, 5, 3, 7, 1]c = [1,2,3,4,5,6]
print(reversed(c)) #<list_reverseiterator object at 0x0000026D0B74C7C8>
"""slice(start,stop,step)  切片，返回一个切片对象左开右闭  返回一个切片对象start:开始数值stop：结束数值step：步长1.步长可以省略，默认是1
"""
a = slice(5,15)
print(a) #slice(5, 15, None)
#把a换成一个迭代对象
b = range(20)[a]
print(b) #range(5, 15)
print(list(b)) #[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

 enumerate(x)   可以迭代序号和值：返回一个迭代对象

"""enumerate(x)  输出序号（下标）和值返回值是一个枚举对象，利用for循环输出
"""
a = enumerate(['a','b','c','d','e'])
print(a) #<enumerate object at 0x000001FFA3DC3AE8>
for xiabiao,zhi in a:print(xiabiao,zhi)

类型相关的内置函数

"""int(x) 将x转换成整数，舍弃小数部分可以把字符串转成整数,但是你的字符串必须是数字字符串 比如"123"
"""
print(int(3.92)) #3
print(int("123")) #123
#print(int("hello"))"""float(x) 将x转换成小数，增加小数部分可以把字符串变成小数,但是字符串必须是数字字符串 比如"123" "22.9"
"""
print(float(12)) #12.0
print(float("22")) #22.0
#print(float("hello"))
"""complex(x) 将x变成复数，增加虚数部分x可以是整数 、小数、数字类型的字符串
"""
print(complex(10)) #(10+0j)
print(complex(3.14)) #(3.14+0j)
print(complex("4.56")) #(4.56+0j)
#complex("hello")"""isinstance(变量,类型)  类型判断,如果变量和类型一致是true，不一致是false变量：自定义变量类型：Str int float list stuple dict set[1,2,3,4] --list列表{"张三":18,"李四":20}----dict字典{1,2,3} ---set集合(1,2) --tuple元组
"""
a = [1,2,3,4]
print(isinstance(a,list)) #True
print(isinstance(a,int)) #False

 # 自定义函数

定义

• 使用关键字def引导；
• def后面是函数的名称，括号中是函数的参数，不同的参数用逗号“,”隔开，参数可以为空，但括号不能省略；
• 函数的代码块要缩进；
• 用一对"""包含的字符串作为函数的说明，用来解释函数的用途，可省略，在查看函数帮助时会显示；
• 使用关键字 return返回一个特定的值，如果省略，返回None。

def  函数名称(参数1，参数2):

       代码块

        return

调用

>>> def add(x,y):

sum01 = x+y

return sum01

>>> add(2,3)

5

参数

  参数可以是0个，也可以是多个

带默认值的参数

定义

  Y的默认值是10

 >>> def cheng(x,y=10):

c = x*y

return c

调用

1. 可以只传一个参数，那这个参数就是x，y是默认值10
2. 如果传入两个参数，那么默认值不起作用

 >>> cheng(2)

20

>>> cheng(2,5)

10

不定数目的参数

定义

1.  * 号代表这个参数是个不确定个数的参数
2. 多个参数要用for进行循环输出
3. 在for循环中进行累加

def add(x,*y):

total = x

for i in y:

     #累加

total += i

return total

调用

相当于x=1  y= 2,3,4,5,6,7,8,9

>>> add(1,2,3,4,5,6,7,8,9)

45

相当于x=1  y=2

>>> add(1,2)

3

返回值

 返回值只能是一个吗，可以是多个吗

 可以返回多个值，多个值之间用逗号隔开

定义

>>> def suanfa(x,y):

sum01 = x+y

cheng01 = x*y

jian01 = x-y

return sum01,cheng01,jian01

调用

>>> suanfa(6,2)

(8, 12, 4)

# 模块

"""import 模块名1,模块2  as 别名导入整个模块，包括模块里面的属性、变量、方法、函数from 模块 import 成员名 as 别名导入模块中的某一个成员，只能用成员包含的东西
"""
#导入系统模块和文件操作模块
"""
import sys,os  as s,os
#打印python的环境变量
print(s.path)
"""
#argv  系统中文件的信息，比如文件路径，文件名字
from sys import argv as ar
print(ar[0])  #d:/axc/Python/PythonTemp/count.py

                                # 第四章python进阶

# 判断语句if

    ## 单分支

语法：

 if 条件:

     代码块

 1.冒号必须是英文状态下

 2.必须要缩进

代码

"""eval(字符串)1.把字符串转换成int类型a = eval("10")print(a) #10print(type(a)) #<class 'int'>2.对字符串进行计算a = "3*2" print(a) #3*2b = eval(a)print(b) #6
"""
#input("请猜一个数字") ---Str
#eval() 把Str转换成int
guess  = eval(input("请猜一个数字"))
if guess ==99:print("恭喜你猜对了") #恭喜你猜对了

## 二分支

语法：

 if 条件:

     代码块

 else:

     代码块

代码

guess  = eval(input("请猜一个数字"))
if guess == 99:print("恭喜你猜对了")
else:print("谢谢惠顾")

## 多分支

语法：

 if 条件:

     代码块

 elif 条件:

     代码块

 elif 条件:

     代码块

  ........

  else:

      代码块

代码

score = eval(input("请输入一个成绩："))
if score >= 90:print("a")
elif 90 > score>=80:print("B")
elif 80 >score>=70:print("C")
elif 70>score>=60:print("D")
else:print("不及格")

## 三目运算符

 if的缩写

满足条件的代码块  if 条件 else 不满足条件的代码块

print("恭喜你，猜对了")if guess == 99 else print("谢谢惠顾")

注意

1. 必须是二分支语句

条件判断以及组合

操作符	数学符号	描述
<	<	小于
<=	≤	小于等于
>=	≥	大于等于
>	>	大于
==	=	等于
！=	≠	不等于

操作符及使用	描述
x and y	两个条件x和y的逻辑与
x or y	两个条件x和y的逻辑或
not x	条件x的逻辑非

# 循环语句for

语法

for 变量 in 遍历结构:

     代码块

Set集合遍历

set01 = {1,2,3,4}
for i in set01:print(i)

无限循环(while)

语法：

a = 10
while a>0:a -= 1print(a)for i in [1,2,3,4,5]:if i == 2:breakprint(i)for i in [1,2,3,4,5]:if i == 2:continueprint(i)n = 100
print(n)if n%2==0 else print(n+1) #100

 while 条件:

     变量改变公式

     代码块

代码

a = 10
while a>0:#变量不断改变，为了满足条件，避免进入死循环a -= 1print(a)

# break continue

break跳出并结束当前整个循环，不执行循环后的语句

continue结束当次循环，继续执行后续次数循环

代码

for i in [1,2,3,4,5]:if i==2:breakprint(i) #1for i in [1,2,3,4,5]:if i==2:continueprint(i) #1

循环加else

语法

for  变量 in 遍历结构:

      代码块

  else:

      代码块  

执行流程

 1.先执行完for循环

 2.执行完以后执行else

代码

for i in [1,2,3,4,5]:print(i)
else:print("循环结束")

同理，while能不能加else，可以，和上面一样

while语法

while <条件> : 

    <语句块1>

else : 

    <语句块2>

#循环结束后，会执行else的代码

# 函数进阶

## 参数传递

参数传递机制

函数参数传递机制和赋值机制是一样的，其本质就是传递内存地址，这就是引用传递

 a传进来的时候传进来的是内存地址

 如果实在不理解，你可以以为是  x= a

def isid(x):#打印参数的内存地址print(id(x))a = 10
#变量的内存地址
print(id(a)) #140731588047408#a变成的参数，打印参数内存地址
isid(a) #140731588047408默认参数
#定义一个带有默认参数的函数
def add(x,y=10):sum01 = x+yreturn sum01"""
1.add(2)  x=2  y=10
2.add(2,3)  x=2  y=3
"""
print(add(2)) #12
print(add(2,3)) #5"""能不能传参传入一个序列类型，比如list，让他默认是[]
"""
def add(list01 = []):list01.append(1)return list01#第一调用
print(add()) #[1]
#第二次调用
print(add()) #[1, 1]
#第三次调用 
print(add()) #[1, 1, 1]

不定数目的参数

一个 *

"""一个* ：代表的是可变参数（就是可以是多个值）
"""
def add(x,*y):sum01 = xfor i in y:sum01 += ireturn sum01print(add(1,2,3,4,5)) #15

两个*

"""**y代表可以使用任意  键值（字典）  作为参数**y就相当于字典类型
"""
def func_add(x,**y):sum01 = x#切记这里是字典的循环for k,v in y.items():print(k,v)#把v（值）进行和x相加sum01 += vreturn sum01"""调用
a=3,b=4,c=5 ----> {"a":3,"b":4,"c":5}
"""
print(func_add(1,a=3,b=4,c=5)) #13

name

1.执行本文件的时候，name==main

#打印name这个属性
#执行本文件的时候，打印的是main，__name__ == __main__
print("1、"+__name__) #1、__main__

2.在被import导入到别的文件的时候，name==文件名字

"""一个文件就是一个模块，导入模块，就相当于导入文件，可以直接写import  文件名字
"""
import 本文件 as bwj
#在其他类中运行导入的文件名字，__name__==文件名字
print(bwj.__name__) #本文件

# 高阶函数

定义

高阶函数是一个（ 以函数为参数，或者以函数为返回值的）函数

函数可以是参数，参数是变量，那么函数可以是变量吗

参数其实就是变量进行了赋值，函数能不能是变量

函数为变量（补充）

  函数为变量并不是高阶函数，只是和大家补充这个知识点

"""函数为变量
"""
#定义一个函数，传入一个参数，求这个参数的平方
def func_pf(x):return pow(x,2)#字典
#已知李四的年龄是5的平方，求李四的年龄
dict01 = {"张三":20,"李四":func_pf}"""调用1.func_pf = dict01["李四"]  根据key获取value,vaule是一个函数对象2.age02 = func_pf(5) #调用函数就能获取年龄
"""
#字典的特点是根据key获取value
age01 = dict01["张三"]
print(age01) #20#顾名思义，通过李四，我们可以拿到函数func_pf
#拿到的是函数对象，我们不能直接打印
func_pf = dict01["李四"]
print(func_pf) #<function func_pf at 0x000001E25A23D048>age02 = func_pf(5)
print(age02) #25
#定义
#普通函数
def func_pf(x):return x**2#高阶函数，以函数为参数
def func_add(func_pf):#x**2+10return func_pf+10#2**2+10
a = func_add(func_pf(2))
print(a) #14

常用的高阶函数

这些常用的高阶函数是以函数为参数的高阶函数

map()

定义

 map(fun,x) 转换，接受一个序列，按照fun的函数逻辑转换成新的序列，返回一个map对象

1. x必须是一个序列
2. 返回一个map对象

代码

"""map(fun,x) 转换，接受一个序列，按照fun的函数逻辑转换成新的序列，返回一个map对象1. x必须是一个序列2.返回一个map对象
"""
def func_add(x):return x+1"""把原来的数据，经过func_add函数以后，每一个都加1，然后输出新的列表
"""
m = map(func_add,[1,2,3,4,5])
print(m) #<map object at 0x00000248E965C788>
print(list(m)) #[2, 3, 4, 5, 6]

filter()

定义

filter(func,x) 过滤，接受一个序列x，按照func函数要求进行转换, 

    func函数返回 True 或 False，最后将返回 True 的元素放到新列表中。

    返回filter对象

代码

"""
filter(func,x) 过滤，接受一个序列x，按照func函数要求进行转换, func函数返回 True 或 False，最后将返回 True 的元素放到新列表中。返回filter对象
"""
def func_ifScore(x):#比较运算符，本身就是返回布尔值的#如果大于等于60就是Ture，否则就是Falsereturn  x>=60f =  filter(func_ifScore,[80,98,70,34,60,59,10])
print(f)  #<filter object at 0x00000232CC78C808>
print(list(f)) #[80, 98, 70, 60]

reduce()

定义

 reduce(func,x) 计算，接受一个序列，把列表中的每一个值按照函数进行累加或者别的运算

   返回一个计算数值

   1.因为是计算，所以我们的func是两个参数

   2.必须要导包

代码

from functools import reduce
"""reduce(func,x) 计算，接受一个序列，把列表中的每一个值按照函数进行累加或者别的运算返回一个计算数值1.因为是计算，所以我们的func是两个参数2.必须要导包
"""
#累加   1+2+3+4+5
def func_add(x,y):return x+ya = reduce(func_add,[1,2,3,4,5])
print(a) #15

zip()

定义

 zip(list01,list02) 拉链、压缩

  用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，返回一个对象

  1.参数必须是可迭代的序列类型

  2.对象里面放的是一个一个的元组

  3.返回一个zip对象

代码

list01 = [1,3,5,7,9]
list02 = [2,4,6,8,10]z = zip(list01,list02)
print(z) #<zip object at 0x00000292EE17C7C8>
#print(list(z)) #[(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]"""数据不一样多了，拉链不一样长了，结果该怎么办呢以短的为基础
"""
list03 = [1,3,5,7,9,11,13]
list04 = [2,4,6]
a = zip(list03,list04)
#print(list(a)) #[(1, 2), (3, 4), (5, 6)]"""a是一个压缩、拉链数据，能不能解压呢，1.符号是*2.zip(*list类型)3.声明两个变量去承接4.zip对象如果执行过了，就不存在了
"""
b = list(a)
list05,list06 = zip(*b)
print(list05) #(1, 3, 5)
print(list06) #(2, 4, 6)

sorted()

定义

 sorted(序列类型的对象,key=函数,reverse=True/False)  排序

  1.reverse=True/False   升序是False 降序是Ture

代码

#list里面可以放任何数据类型
list01 = [{"name":"张三","age":20},{"name":"李四","age":30},{"name":"王五","age":18},{"name":"小明","age":8}]#按照年龄进行排序
#定义一个函数，返回一个年龄
def func_age(list01):#根据key（age）获取value（年龄）age01 = list01["age"]return age01s = sorted(list01,key=func_age,reverse=False)
print(s)
#[{'name': '小明', 'age': 8}, {'name': '王五', 'age': 18}, {'name': '张三', 'age': 20}, {'name': '李四', 'age': 30}]

偏函数（补充）

语法

 from functools import partial

  partial(fun,x)

   fun:你的函数

    x：你要固定的函数中参数

代码

#x的y次方
def func01(x,y):return x**y"""简化2上面的这种这能固定x，没办法固定y，使用偏函数解决这个bug偏函数1.partial(fun,你要固定的那个参数x)  可以固定函数中的任意一个参数2.导包 from functools import partialdef func01(x,y=2):return x**y
"""
from functools import partial
#func = func01(x,y=2)
func = partial(func01,y=2)
a =  func(3) #x=3
#a = x**2=3**2=9
print(a) #9#可以固定多个参数，可以把x和y都固定住
from functools import partial
#func = func01(x=10,y=2)
func = partial(func01,y=2,x=10)
a =  func() 
print(a) #100

lambda表达式

定义

lambda表达式是一行函数。在其他语言中叫做匿名函数

语法

 lambda 参数1,参数2,参数n : 逻辑

代码

"""lambda表达式：一行函数理解为函数的简写
"""def func01(x,y):return x**ylambda x,y:x**y

# 函数的递归

定义

 递归是指函数在执行过程中调用了本身。简单来说就是自己调用了自己

 1.自己调用自己

 2.一定要有一个条件，进行退出调用

代码

"""递归是指函数在执行过程中调用了本身。简单来说就是自己调用了自己1.自己调用自己2.一定要有一个条件，进行退出调用
"""
"""阶乘：比如说给一个数据5，阶乘5*4*3*2*1n = 5*(5-1)n =n*(4-1)n =n*(3-1) n =n*(2-1)总结规律n! = n*(n-1)
"""
def func_jc(n):if n==1:return 1else:return n*func_jc(n-1)print(func_jc(5)) #120

效率的比较

 我能用普通函数写出来，为什么非要学递归

import time
"""函数递归
"""
def func_fb(n):if n==0 or n==1:return 1else:return func_fb(n-2)+func_fb(n-1)"""非递归#下标是从0开始的
"""
def func(n):#初始化两个变量a,b=1,1#range(5) ---->0,1,2,3,4for i in range(n):a,b=b,a+breturn a#perf_counter 以秒为单位进行记时间
start01 = time.perf_counter()
func_fb(10)
stop01= time.perf_counter()
print("递归函数的调用时间 %s" %(stop01-start01))#process_time 以秒为单位进行记时间
start02 = time.perf_counter()
func(10)
stop02= time.perf_counter()
print("非递归函数的调用时间%s"%(stop02-start02))
"""
递归函数的调用时间 5.050000000000193e-05
非递归函数的调用时间7.3000000000017495e-06
"""

# 装饰器

定义

 1.装饰器是一个函数

 2.装饰器是一个 为函数添加新的属性  的函数

 3.通过闭包对函数添加新的属性

语法

 语法

 1.def func_a()  #带有新特新的闭包函数

   @def func_a

 2.def func_b()  #被修饰的函数

相当于func_a(func_b)

可以是多个@，如果是多个@的话，从下往上运行

代码1

"""1.装饰器是一个函数2.装饰器是一个 为函数添加新的属性  的函数3.通过闭包对函数添加新的属性
闭包函数:函数的子函数就是闭包函数
"""
#装饰器
def zhuangxiudui(a):#闭包函数def zhuangxiufangan():print("贴瓷砖")a()print("隔音棉")return zhuangxiufangan@zhuangxiudui
def qiang():print("来看看，就是这三面强")
#16-18行相当于  zhangxiudui(qiang)
#把qiang作为参数，传给了装修队这个函数@zhuangxiudui
def men():print("我是门")
"""22-24行代表  zhangxiudui(men)
"""#一周之后我来验货，来看看强弄好了没
qiang()
"""
贴瓷砖
来看看，就是这三面强
隔音棉
"""

代码2

#装饰器
def zhuangxiudui(a):#闭包函数def zhuangxiufangan():print("贴瓷砖")a()print("隔音棉")return zhuangxiufangandef gaojizhuangxidui(b):def zhuangxiufangan():#你现在的墙是由瓷砖由隔音棉b()print("拆除瓷砖")print("拆除隔音棉")print("刷粉漆")return zhuangxiufangan"""本来把墙给装修队，结果他装修坏了，我有找了一个高级装修队，进行重新装修gaojizhuangxiudui(zhuangxiudui(qiang))b=zhuangxiudui(qiang)a=qiang
"""
@gaojizhuangxidui
@zhuangxiudui
def qiang():print("来看看，就是这三面强")qiang()
"""
贴瓷砖
来看看，就是这三面强
隔音棉
拆除瓷砖
拆除隔音棉
刷粉漆
"""

Wraps()函数

定义

1. @wraps(gaoyuanyuan) 保留高圆圆这个函数的所有属性和方法

2. from functools import wraps

Wraps(被修饰的物体) 保留被修饰物体的属性和函数  

# 迭代器

定义

 迭代器是一个可以遍历容器的一个对象

1. 迭代器返回一个对象

2. 那些东西可以进行迭代

  容器类型的---list  set  字典 字符串

"""迭代器#注意是两个下划线list01.__iter__() 返回一个迭代器对象<list_iterator object at 0x0000024037E0C588>
"""
list01 = [1,2,3,4]
#注意是两个下划线
a =  list01.__iter__()
print(a) #<list_iterator object at 0x0000024037E0C588>
"""1.我听要他何用，他是一个对象，我想要的是值迭代器对象.__next__() 返回一个值2.他只能返回第一个值吗  no因为next()可以记忆位置，每次你调用一次，他会记住这位置，然后下一次从下一个位置开始3.我要是一直调用，可以吗报错StopIteration，没有数据了我们的next没有办法回头，不会从头开始，他只会从记忆的位置的开始
"""
print(a.__next__()) #1
print(a.__next__()) #2
print(a.__next__()) #3
print(a.__next__()) #4
print(a.__next__()) #报错

迭代

list01 = [1,2,3,4]
#注意是两个下划线
a =  list01.__iter__()
"""迭代对象的遍历1.__next__() 不会从头开始， 每次从记忆的位置开始2.for循环就相当于是不断的打印__next__()。但是为什么没报错自己抛出StopIteration，然后停止循环
"""
for i in list01:print(i)

迭代对象

1. 那些东西可以进行迭代

  容器类型的---list  set  字典 字符串

为什么是两个下划线

有些方法以双下划线 “__” 开头和结尾，它们是Python的魔法函数，用于特殊用途

Next()

.next()

.__Next__()

__init__()

__iter__()

Func_sum()

# 生成器

定义

生成器也是一种迭代器，但是你只能对其迭代一次。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个特殊的迭代器。

生成器可以一边循环一边计算

优点是节省内存

关键字是：yield

总结

1. 生成器都是迭代器，迭代器不一定是生成器

2. 字符串，列表，元组，字典，集合都可以被for循环，说明他们都是可迭代对象

3. 迭代器的两个方法：1.有__iter__() 2. 有__next__()

4. isinstance() 类型判断。isinstance(a,Iterable) 判断a 是否是可迭代对象。

# 推导式

推导式是从一个或者多个迭代器快速创建序列的一种方法。

语法

[逻辑/结果 for i in 序列类型的变量]

"""
普通循环
"""
for i in [1,2,3,4]:print(i)
"""
推导式
"""
[print(i) for i in [1,2,3,4]]

列表类型

"""推导式
"""
list01 = [1,2,3,4]
a=  [i+1 for i in list01]
print(a) #[2, 3, 4, 5]
print(type(a)) #<class 'list'>

元组类型

list01 = [1,2,3,4]
#把里面的代码看成一个整体，一个对象
#利用我们的tuple()函数
a=  tuple(i+1 for i in list01)
print(a)  #(2, 3, 4, 5)
print(type(a)) #<class 'tuple'>#把3+2变成一个整体
(3+2)/9

集合类型

list01 = [1,2,3,4]
a=  {i+1 for i in list01}
print(a) #{2, 3, 4, 5}
print(type(a)) #<class 'set'>

字典类型

dict01 = {"王五":20,"张三":50,"李四":80,"赵六":18}for k,v in dict01.items():print(k,v){print(k,v) for k,v in dict01.items()}

# 异常处理

语法

Try – except-else

"""try -except-elsetry:代码块except <错误的名字(可写可不写)>:代码块...........else:代码块
可以把else去掉
try:代码块except <错误的名字(可写可不写)>:代码块
注意：1.try不能单独使用2.错误的名字(可写可不写)
运行结果：报错(除数是0)，运行的是except不报错(除数不是0)，运行的是else
"""
try:s = eval(input("请输入一个数字："))a = 10/s
except ZeroDivisionError:print("除数不能是零")
else:print("除数是正常的，运行成功")

Try-finally

"""
Try-finallytry：代码块finally:代码块
执行结果：无论报不报错最终都会执行
"""
#control+ctry:s= input("请输入内容")
finally:print("异常退出")

Raise关键字

"""raise：无论代码是否异常，他自己会触发异常语法：raise 异常名称
"""
try:s = eval(input("请输入一个除数："))a = 10/s#无论你的除数等不等于0，他都会报错raise ZeroDivisionError
except ZeroDivisionError:#except是异常的时候给出的警告print("警告：除数不能为0")
"""
请输入一个除数：3
警告：除数不能为0
"""

常见的异常列表(要求再认)

BaseException	所有异常的基类
SystemExit	解释器请求退出
KeyboardInterrupt	用户中断执行(通常是输入^C)
Exception	常规错误的基类
StopIteration	迭代器没有更多的值
GeneratorExit	生成器(generator)发生异常来通知退出
StandardError	所有的内建标准异常的基类
ArithmeticError	所有数值计算错误的基类
FloatingPointError	浮点计算错误
ValueError	传入无效的参数
ZeroDivisionError	除(或取模)零 (所有数据类型)
KeyError	映射中没有这个键
AttributeError	对象没有这个属性

作用域

是按照变量的查找顺序 L>E>G>B

L(local) 局部作用域

"""
L(local) 局部作用域
"""
def func():#a是函数中的变量，是局部变量,只能在函数中使用a=10print(a)
#a是不存在的
print(a)E(Enclosing) 闭包函数中的作用域nonlocal  :把闭包外的变量引用过来
#刚出生的年龄，是全局变量，意味这谁都是从这个年龄开始的
age = 1
def qunian():#闭包外的变量，局部变量  4-11能用age = 19def jinian():"""#把全局变量引用过来，那么就是把age=1引用过来global age我们想要引用的是闭包外面的变量nonlocal  :把闭包外的变量引用过来"""nonlocal age#闭包里面的变量 ，局部变量 7-9行能用age=age +1print("今年的年龄",age)print("去年的年龄",age)return jinian#qunian()返回的是return jinian
jinian = qunian()
#所以还要调用一下今年这个函数jinian()
jinian()
#今年的年龄 20

# G(Global) 全局作用域

global  把全局的age引用过来

"""
G(Global) 全局作用域
"""
#全局
age = 20
def func():#把全局的age引用过来global age#局部#前面的a相当于是重新赋值的a，是局部的#后面的a是要进行相加的数据，所以要有这个数据，所以是全局的age=1 + agereturn ageprint(func()) #30

B(Built-in) 内建作用域

系统固定模块里面的变量，比如 int, bytearray 等。

比如函数名 abs、char 和异常名称 BaseException、Exception 等等。

总结

是按照变量的查找顺序 L>E>G>B

本文标签： 第三章第四章