概要：深浅拷贝、函数、lambda、内置函数、文件操作
一、深浅拷贝
1.对于字符串、数字来说，赋值、深拷贝、浅拷贝的结果是一样的，都是用的内存中的同一个地址。
如下图所示：
1 import copy 2 ‘‘‘ 3 4 a1 = 123 5 a2 = 123 6 #a2 = a1 7 print(id(a1)) 8 print(id(a2)) 9 #浅拷贝，内存中的地址一样 10 a3 = copy.copy(a1) 11 print(id(a1)) 12 print(id(a3)) 13 #深拷贝，内存中地址一样 14 a4 = copy.deepcopy(a1) 15 print(id(a1)) 16 print(id(a4)) 17 #结论：对于字符串、数字来说，赋值，深浅拷贝用的都是内存中的同一个地址。
2.其他类型，如列表、字典、元组
对于字典、元组、列表 而言，进行赋值、浅拷贝和深拷贝时，其内存地址的变化是不同的
赋值：只是新创建了一个变量，该变量还是指向原来的内存地址
n1 = {‘k1‘:‘v1‘,‘k2‘:123,‘k3‘:["alex",678]}
n2 = n1
浅拷贝：在内存地址里只拷贝一层，字典里的元素没拷贝
深拷贝：有多少层拷贝多少份，在内存中将所有的数据重新创建一份
1 #!/usr/bin/env python3
2 #author:Alnk
3 import copy
4
5 #其他，如元组，列表，字典...
6 n1 = {‘k1‘:‘v1‘,‘k2‘:123,‘k3‘:["alex",678]}
7
8 #赋值 --内存地址还是一样的
9 n2 = n1
10 print(id(n1))
11 print(id(n2))
12
13 #浅拷贝：在内存中只额外创建第一层数据
14 #第一层的内存地址已经不一样了
15 n3 = copy.copy(n1)
16 print(id(n1))
17 print(id(n3))
18 #其他层的内存地址是一样的
19
20
21 #深拷贝：在内存中将所有的数据重新创建一份。更改拷贝后的数据，原来的数据不会收到影响
22 n4 = copy.deepcopy(n1)
23 print(id(n1))
24 print(id(n4))
25 #
26 print(id(n1[‘k1‘]))
27 print(id(n4[‘k1‘]))
28 print(id(n1[‘k2‘]))
29 print(id(n4[‘k2‘]))
30 print(id(n1[‘k3‘]))
31 print(id(n4[‘k3‘]))
32 print(id(n1[‘k3‘][0]))
33 print(id(n4[‘k3‘][0]))
1 import copy
2
3 #示例
4 #监控模版
5 #已经被监控的10台机器当CPU超过80时报警，现在要新添加10台机器的监控，CPU超过60就报警
6 dic = {
7 "cpu":[80,],
8 "mem":[80,],
9 "dis":[80,]
10 }
11
12 ###如果用赋值的话则会把原来老的监控指标也更改了###
13 new_dic = dic
14 new_dic[‘cpu‘][0] = 60
15 print("old:",dic)
16 print("new:",new_dic)
17 ###################################################
18
19 ####如果用浅拷贝的话则会把原来老的监控指标也更改了####
20 new_dic = copy.copy(dic)
21 new_dic[‘cpu‘][0] = 60
22 print("old:",dic)
23 print("new:",new_dic)
24 ###################################################
25
26 #####深拷贝不会更改原来老的监控指标#####
27 new_dic = copy.deepcopy(dic)
28 new_dic[‘cpu‘][0] = 60
29 print("old:",dic)
30 print("new:",new_dic)
31 ###################################################
深浅拷贝练习
二、函数
1.基本概念
1 #!/usr/bin/env python3 2 #author:Alnk 3 4 def mail(): 5 n = 123 6 n+=1 7 print(n) 8 9 #调用函数 10 mail() 11 12 #赋值 ，f 指向了mail函数的内存地址 13 f = mail 14 #调用 15 f()
2.函数返回值
函数如果没有return，那么默认返回None
return作用：
返回一个值
中断函数
1 #!/usr/bin/env python3 2 #author:Alnk 3 ‘‘‘ 4 #函数返回值练习（函数默认返回值为None） 5 def mail(): 6 n = 123 7 n+=1 8 return 123 9 10 #执行函数，并且赋值给ret，拿到返回值 11 ret = mail() 12 print(ret) 13 ‘‘‘ 14 15 #return 返回一个值并且中断函数操作 16 def show(): 17 print(‘a‘) 18 return [11,22] 19 print(‘b‘) 20 ret = show() 21 print(ret)
扩展：pycharm断点调试的方法
3.函数参数
函数参数可分为：
普通参数（又叫位置参数）
默认参数 #注意默认参数必须指向不可变对象！
动态参数：
可变参数 #调用的时候需要先组装出一个list或tuple
关键字参数 #关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict
命名关键字参数
在Python中定义函数，可以用位置参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：位置参数、默认参数、可变参数、命名关键字参数和关键字参数。
1 #!/usr/bin/env python3
2 #author:Alnk
3 ‘‘‘
4 #1.没有参数
5 def show():
6 pass
7
8
9 #2.位置参数 ：一个参数
10 def show(arg):
11 print(arg)
12 show(‘kkkk‘)
13 #两个参数,或者多个参数
14 def show(arg1,arg2):
15 print(arg1,arg2)
16 show(‘kkkk‘,‘bbbb‘)
17
18
19 #3.默认参数 -- 定义默认参数要牢记一点：默认参数必须指向不变对象！
20 def show(a1,a2=333):
21 print(a1)
22 print(a2)
23 show(‘aaa‘)
24 show(‘aaa‘,‘bbb‘)
25 #指定参数
26 def show(a1,a2):
27 print(a1)
28 print(a2)
29 show(a2=123,a1=999)
30
31
32 #4.动态参数（可变参数）--生成一个元组
33 def show(arg):
34 print(arg)
35 def show2(*arg):
36 print(arg,type(arg))
37 show(1)
38 show2(1)
39 show2(1,2,3,4,5)
40
41 #动态参数（关键字参数） --生成一个字典
42 def show3(**kw):
43 print(kw,type(kw))
44 show3(a1=8)
45 show3(a1=8,a2=88)
46 #可变参数+关键字参数 --*args在前，**kw在后
47 def show(*args,**kw):
48 print(args,type(args))
49 print(kw,type(kw))
50 l = [11,22,33]
51 d = {"n1":66,"a1":99}
52 #show(11,222,333,44,a="bb",n3="cc") #传参数时注意位置
53 show(l,d) #都放进*args里面去了
54 show(*l,**d) #把列表或元组整个赋值给动态参数，需要加 * 或者 **
55
56 #动态参数(命名关键字参数)
57 #对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过kw检查。
58 #如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下
59 #和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数
60 def person(name, age, *, city, job):
61 print(name, age, city, job)
62 person(‘Jack‘, 24, city=‘Beijing‘, job=‘Engineer‘)
63 person(‘Jack‘, 24, job=‘Beijing‘, city=‘Engineer‘)
64 #如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了
65 def person(name, age, *args, city, job):
66 print(name, age, args, city, job)
67 #person(‘Jack‘, 24, ‘Beijing‘, ‘Engineer‘) #调用失败
68
69
70 #格式化
71 s1 = "{0} is {1}"
72 l = ["alnk","shuaiguo"]
73 #result = s1.format("alnk","shuaiguo")
74 result = s1.format(*l)
75 #print(s1.format("alnk","shuaiguo"))
76 print(result)
77
78 s1 = "{name} is {acter}"
79 result = s1.format(name="alnk",acter="666")
80 print(result)
81 d = {"name":"alnk","acter":666}
82 result = s1.format(**d)
83 print(result)
84 ‘‘‘
代码演示
三、lambad
1 #!/usr/bin/env python3 2 #author:Alnk 3 4 def f1(a): 5 b = a + 1 6 return b 7 ret = f1(4) 8 print(ret) 9 10 #lambda表达式 --简单的函数表式方式 11 f2 = lambda a:a+1 #创建了形式参数a，创建了函数内容 a+1 ，并且把结果return 12 ret = f2(99) 13 print(ret)
四、内置函数
目前熟悉下图标注的函数即可
1 #!/usr/bin/env python3
2 #author:Alnk
3 ‘‘‘
4 #abs() --绝对值
5 print(abs(11))
6 print(abs(-11))
7
8 #all() --传一个序列，会去循环该序列，一旦存在假的值就会返回False
9 print(all([]))
10 print(all(["",]))
11 print(all([0,1,2]))
12 #以下都为假，空的类型
13 print(bool(None))
14 print(bool(""))
15 print(bool([]))
16 print(bool(0))
17 print(bool({}))
18
19 #any() --只要有一个为真，就返回True
20 print(any([0,1,2]))
21
22 #bin() --返回二进制
23 print(bin(100))
24
25 #bool() --布尔值
26 print(bool(None))
27 print(bool(""))
28 print(bool([]))
29 print(bool(0))
30 print(bool({}))
31 print(bool(1))
32
33 #chr() --把字符转为ascii码
34 print(ord(‘a‘))
35
36 #ord() --把ascii码转为字符，
37 print(chr(97))
38
39 #dict() --创建一个字典
40 a =dict(v1=‘k1‘,v2=‘k2‘)
41 print(a)
42
43 #dir() --当前变量所有的方法
44 a = ()
45 print(dir(a))
46
47 #divmod() --返回一个元组，第一个元素位商，第二个元素位余数
48 print(divmod(4,2))
49
50 #enumerate() --输出编号
51 li = ["a","b","c"]
52 for i,item in enumerate(li,1):
53 print(i,item)
54
55 #eval() --字符串里的数字乘积
56 print(eval("6*8"))
57
58 #filter() --用于过滤序列
59 li = [11,22,33,44]
60 def fun(x):
61 if x > 33:
62 return True
63 else:
64 return False
65 l = filter(fun,li) #过滤
66 print(list(l))
67
68 #map() --加工
69 li = [11,22,33,44]
70 new_li = map(lambda x:x+100,li)
71 l = list(new_li)
72 print(l)
73
74 #float() --创建小数
75 a = 1
76 b = float(a)
77 print(b)
78
79 #help() --帮助函数
80
81 #id() --查看对象在内存中的地址
82
83 #input() --输入函数
84
85 #int() --创建一个整数
86
87 #len() --判断一个对象的长度
88 l1 = [1,23,44]
89 print(len(l1))
90 s1 = "str1"
91 print(len(s1))
92
93 #list() --创建一个列表
94 a = list((1,2,3,4))
95 print(a)
96
97 #max() --返回最大值
98 print(max(1,2,3,4))
99
100 #min() --返回最小值
101 print(min(1,2,3,4))
102
103 #oct() --八进制
104 print(oct(10))
105
106 #pow() --返回（x的y次方） 的值。
107 print(pow(2,5))
108
109 #range() --返回一个序列
110 print(range(1,10))
111
112 #reversed() --反转迭代
113 l1 = [‘a‘,‘b‘,‘c‘]
114 l2 = reversed(l1)
115 for i in l2:
116 print(i)
117
118 #round() --四舍五入
119 print(round(8.9))
120 print(round(8.4))
121
122 #set() --集合
123 a = set([1,2,3])
124 print(a)
125
126 #sort() --排序
127 a = [‘b‘,‘c‘,‘a‘]
128 a.sort()
129 print(a)
130
131 #str() --创建一个字符串
132 a = str("abcde")
133 print(a)
134
135 #sum() --求和
136 print(sum([1,2,3],3))
137 print(sum([1,2]))
138
139 #tuple() --元组
140 t = tuple([1,2,3,])
141 print(t)
142
143 #type() --返回对象的类型
144 a = 1
145 print(type(a))
146
147 #vars() --返回对象的属性和属性值的字典对象
148 class fo():
149 a = 1
150 print(vars(fo))
151
152 #zip() --映射
153 x = [1,2,3]
154 y = [4,5,6]
155 z = [7,8,9]
156 zipped = zip(x,y,z)
157 print(list(zipped))
158 ‘‘‘
五、文件操作（open()函数）
1 #!/usr/bin/env python3 2 #author:Alnk 3 ‘‘‘ 4 #read 按照字符来读的 5 f = open(‘log.txt‘,‘r‘,encoding=‘utf-8‘) 6 ret = f.read(2) #按照字符读，不是按照字节 7 f.close() 8 print(ret) 9 10 #tell() --查看当前指针的位置，按照字节来的 11 f = open(‘log.txt‘,‘r‘,encoding=‘utf-8‘) 12 f.read(2) 13 print(f.tell()) #按照字节，不是字符 14 f.close() 15 16 #seek --用来指定指针的位置，按照字节来的 17 f = open(‘log.txt‘,‘r‘,encoding=‘utf-8‘) 18 f.seek(3) 19 print(f.read()) #不加参数，全部读取，加参数，指定读取字符。是字符字符字符。。。 20 f.close() 21 22 #truncate() --截取指针前面的字节，并且删除指针后面的数据 23 f = open(‘log.txt‘,‘r+‘,encoding=‘utf-8‘) 24 f.seek(3) 25 #print(f.read()) 26 print(f.truncate()) 27 f.close() 28 ‘‘‘
原文地址：https://www.cnblogs.com/lichengguo/p/9181987.html
时间： 2024-10-22 22:11:20