python3自动化学习03

 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 #结论：对于字符串、数字来说，赋值，深浅拷贝用的都是内存中的同一个地址。

 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 #!/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()

 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)

 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 ‘‘‘

 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 ‘‘‘

 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 ‘‘‘