8、类型转换、深浅拷贝
8.1 数据转换
数据类型
- int 整型 float浮点数 bool 布尔值 complex复数
- str 字符串
- list 列表
- tuple 元组
- dict 字典
- set 集合
1# 类型转换 2int() 3num = int("123") 4if num == 123: 5 print("等于123") 6 7num = 123 8n = str(num) #转换为字符串 9print(type(n)) 10 11 12# eval() 用来执行一个字符串表达式，并返回表达式的值 13res = eval("10+10") 14print(res) #得到20 15res = eval("[1,2,3]") 16print(type(res)) # 转换为list 17 18 19b = list("abc") 20c = tuple(b) #转换为元组 21print(c) 22 23 24op = {} #这是字典 25print(type(op)) # <class 'dict'> 26 27 28op2 = set() #集合类型 29op2 = set("abcdefg") #集合类型 30print(type(op2)) #集合 31 32 33# 转换为字典 34li = ["name","age"] 35value = ["zhangsan",18] 36dic = dict(zip(li,value)) 37 38 39li = [('name','zs'),('age',18)] 40dic = dict(li) 41
8.2 浅拷贝
前言：数据赋值
1 2li = [1,2,3] 3li2 = li 4li.append(4) 5print(li2) #对li修改，li2也跟着修改
浅拷贝（数据半共享）：会创建新对象，拷贝第一层的数据，嵌套层会指向原来的内存地址
外部不同，但是内部是相同的
1import copy 2a = [1,2,[3,4]] # [3,4] 指的是嵌套层 3b = copy.copy(a) 4print(a,id(a)) #通过id来查看变量a的地址 5print(b,id(a)) 6# a和b是不同的。 7a.append(5) 8print(a) #[1,2,[3,4],5] 9print(b) #[1,2,[3,4]] 10 11a[2].append(5) # 给嵌套列表中插入数据 12print(a) # [1,2,[3,4,5],5] 13print(b) # [1,2,[3,4,5]] 14 15
8.3 深拷贝
深拷贝：数据完全不共享，a和b完全独立
1import copy 2a = [1,2,[3,4]] 3b = copy.deepcopy(a) 4 5print(a) 6print(b) 7 8b.append(5) 9print(a) # [1,2,[3,4],5] 10print(b) # [1,2,[3,4]] 11 12a[2].append(5) 13print(a) # [1,2,[3,4,5],5] 14print(b) # [1,2,[3,4]] 15
8.4 可变对象与不可变对象
可变对象：存储的对象可以被修改
常见的可变类型：
- 列表 list
- 字典 dict
- 集合 set
不可变对象
- int
- bool
- float
- complex
- str 字符串
- tuple 元组
1# 不可变对象 2# 不可以修改，修改相当于重新给一个值 3n = 10 4print(n) 5print(id(n)) #查看内存地址 6n += 1 7print(id(n)) # 内存地址不一样 8 9 10st = "hello" 11print(id(st)) #查看内存地址 12st = st + 'python' 13print(id(st)) #内存地址不同 14 15 16tu = (1,2,3) 17print(id(tu)) 18
1# 可变 list/dict/set 2# 变量对应的值可以修改，但是内存地址保持不变 3 4li = ['上九天揽月','床前明月光'] 5print(id(li)) 6li.append('张三') 7print0(id(li)) #两个内存地址不会改变 8 9 10dic = {"name":"张三","age":18} 11print(dic) 12print(id(dic)) 13dic["name"] = "吃花椒" 14print(id(dic)) 15 16
9 函数基础
9.1 函数
函数的定义：
1def 函数名(): 2 函数体 3 4
9.2 函数的返回值
return 给函数的调用者返回值，函数中遇到return，此函数不再继续执行
9.3 函数的参数
函数的参数有必选参数、默认参数、可变参数、关键字参数
- 必选参数： 写几个就传几个 def funa(a,b)
- 默认参数： def funa(a=12)
- 可变参数： 将实参所有的位置参数接收，放在一个元组里 def funa(* args)
- 关键字参数： 接受所有的关键字参数，将其转换为一个字典。 def funa(**kwargs)
9.4 函数的嵌套
1def funa(): 2 def funb(): 3 print("这是内部函数") 4 funb() 5 6funa()
可变参数
1 2def fun(a,b,*c,d=5): 3 print(a) 4 print(b) 5 print(c) 6 print(d) 7 8fun(1,2,3,4,7) 9 10# 输出结果 11# 1 12# 2 13# (3,4,7) 14# 5 15 16 17 18
1 2def fun1(a,b): 3 return a+b 4 5fun1(*(1,2)) 6# 返回3 7fun1(*[1,2]) 8# 返回3 9fun1(*{1,2}) 10# 返回3
10 函数进阶
1.定义函数def 返回值return 2.函数参数，预备参数，默认参数，可变参数 3.函数嵌套 在一个函数中调用一个函数，在一个函数中定义一个函数
10.1 作用域
10.1.1 作用域的概念
局部变量
只在函数内部有作用
从定义位置开始到函数定义结束位置有效
全局变量
函数外部定义的变量整个范围有效
1price = 2 2 3def st1(): 4 print(f"全局变量{price}") 5def st2(): 6 print(f"全局变量{price}") 7 8# 输出结果 9# 2 10# 2
1price = 2 2 3def st1(): 4 print(price) 5 6def st2(): 7 price=1.2 8 print(price) 9print(price) 10st1() 11st2() 12print(price) 13 14#输出结果 152 162 171.2 182 19 20# 因为函数内部用变量，现在里面找，里面找不到再到外面找
全局变量和局部变量相同
1a = 100 2def funa(): 3 a = 200 #局部变量 4 print(a) 5# 输出结果 6200 7 8# 当局部变量和全局变量相同的时候，优先使用局部变量
10.1.2 global
如何修改全局变量
global 将变量提升为全局变量
global 将会修改全局变量
1global 将变量名声明为全局变量 2 3a = 100 4def funa(): 5 global a 6 print(a) 7 a = 200 8print(a) 9 10## 输出结果为 11## 200 12## 200 13
global name 将局部变量name变成了全局变量
1def speak(): 2 global name ,num 3 name = "jiuge" 4 print(name) 5 6def work(): 7 print(num) 8 9speak() 10print(name) 11
10.1.3 nonlocal
nonlocal 外层函数的局部变量，只能在嵌套函数中使用
-
使用与global类似
-
将变量声明为外层变量（外层函数的局部变量，而且不能是全局变量）
1 2def out_fun(): 3 num = 10 4 def inner_fun(): 5 nonlocal num 6 num = 20 7 inner_fun() 8 print(num) 9 10out_fun() 11 12# 输出结果 13# 20
1 2def out_fun(): 3 a = 10 4 def inner1(): 5 a = 5 6 def inner2(): 7 nonlocal a 8 a = 20 9 print(a) 10 inner2() #调用函数 11 print(a) 12 inner1() 13 print(a) 14 15#输出结果 16# 20 17# 20 18# 10
10.2 匿名函数
语法： 函数名 = lambda 形参:返回值
lambda是定义匿名函数的关键字，相当于函数的def
调用： 结果 = 函数名(实参)
1 2def funa(a,b): 3 return a+b 4funa(1,2) 5 6# 等价于 7res = lambda a,b : a+b 8res(1,2) 9
1 2n1 = 5 3n2 = 8 4 5# 如果if条件为真，就打印为print(n1) 6print(n1) if n1 < n2 else print(n2) #三目运算符 7 8we = lambda n1,n2: "正确" if n1<n2 else "错误" 9print(we(1,2))
10.3 内置函数
10.3.1 max，min，range方法
比如说max，min，range等系统自带的内置函数
1#查看所有的内置函数 2import builtins 3print(dir(builtins)) 4
1 2abs(17) #返回绝对值 3sum([1,2,3]) #求和 4min 5zip 6
10.3.2 zip函数
1a = [1,2,3] 2b = [4,5,6,5] 3for i in zip(a,b): 4 print(i) 5 6# 输出结果 7# (1,4) 8# (2,5) 9# (3,6)
10.3.3 reduce函数
1## reduce方法 2 3# 求和 4from functools import reduce 5res = reduce(lambda x,y : x+y , [1,2,3,4,5]) 6 7# 求积 8from functools import reduce 9res = reduce(lambda x,y:x*y , [1,2,3,4,5]) 10 11#求阶乘 求5！ 12from functools import reduce 13res = reduce(lambda x,y:x*y , range(1,6))
10.3.4 map函数
1 2# ============ 3l = [1,2,3] 4def funa(x) 5 return x+3 6mp = map(funa,l) #依次作用到列表中的每个元素上，保存到新的list之中 7print(list(mp)) 8# 返回结果 [4,5,6] 9# =================== 10 11 12# 通过map给每个元素开平方 13res = map(lambda x : x*x , [1,2,3,4,5]) 14res = list(res) 15#得到结果 16#[1,4,9,16,25] 17 18 19
10.4 拆包
1 2# 拆包 3li = [1,2,3,5] 4a,*b = li 5 6print(a) 7print(b) 8# 输出结果 9# 1 10# [2,3,5] 11 12# ====================== 13 14# ======================= 15tu = (1,2,3,4) 16a,b,c,d = tu 17print(a,b,c,d) 18# 输出结果 19# 1,2,3,4 20 21#===================== 22 23a,*b,c = [1,2,3,4,5] 24print(a) 25print(b) 26print(c) 27# 输出结果 28# 1 29# [2,3,4] 30# 5 31 32*a,b = [1,2,3] 33print(a) 34print(b) 35# 输出结果 36# [1,2] 37# 3
1l = {"姓名":1, "名称":2} 2*a,b = l 3print(a) 4print(b) 5# 输出结果 6# ['姓名'] 7# 名称 8 9
10.5 递归函数
概念：一个函数在内部不调用其他的函数，而是调用本身
自己调用我自己
递归函数的要点
- 必须要有一个明确的结束条件
- 每进行更深一层的递归时，问题规模相比上次都要有所减少
- 相邻两次重复之间有紧密的联系
1# 计算1-20的累加和 2 3def add(): 4 s = 0 5 for i in range(1,21): 6 s += i 7 print(s) 8 9 10def funa(n): 11 if n==1: 12 return 1 13 else: 14 return n + funa(n-1) 15print(funa(5))
1#求斐波那契数列 2 3 4def fib(n): 5 if n==2 or n==1: 6 return 1 7 else: 8 return fib(n-1)+fib(n-2) 9 10print(fib(5))
10.6 闭包
在嵌套函数的前提下，内部函数使用了外部函数的变量，而且外部函数返回了内部函数
我们就把使用了外部函数变量的内部函数称为闭包
构成条件
- 函数中嵌套了一个函数
- 内存函数使用了外层函数的变量
- 外层函数的返回值是内层函数的函数名
1def outer(): #外部函数 2 n = 10 3 def inner(): #内部函数 4 print(n) #内部函数用到了外部函数的变量 5 6 return inner 7 8ot = outer() #这是一个函数 9ot() #调用函数
1 2def test(): 3 print("打印test") 4 5t = test 6t() #相当于调用了test函数 7 8
1def outer(m): 2 3 def inner(n): 4 return m+n 5 return inner 6 7inn = outer(5) 8inn(6) 9 10# 返回结果 11# 11 12 13# 第二种方法 14outer(5)(6) 15