老男孩14期自动化运维day3随笔和作业

1.文件读写：
r’：读
‘w’：写
‘a’：追加
‘r+’ == r+w（可读可写，文件若不存在就报错(IOError)）
‘w+’ == w+r（可读可写，文件若不存在就创建）
‘a+’ ==a+r（可追加可写，文件若不存在就创建）
‘rb’　　‘wb’　　‘ab’　　‘rb+’　　‘wb+’　　‘ab+’
加b是以二进制形式打开文件

读的方式：
f.read() 一次读所有放入内存。当文件过大时，一起放入内存会出现内存占满的情况，因此只适用于读比较小的文件
for line in f.readlines() 一次读一行数据，放入内存
for line in f 一行一行读，且内存只保留一行数据，读下一行时释放上一行占用的内存。最好使用这种方式。
代码如下

#!/usr/bin/env python
# coding:utf-8
# Author:Yang
product_list=[]
with open("F:/homework/day2/homeworkday2.txt") as f:
    for line in f: # 一行一行读 且内存里只保存一行 最好用这种方式
        product_list.append(list(line.strip('\n').split(',')))



   # print(f.read())# 一次读所有都放进内存
   # for line in f.readlines(): # 一次读一条 放入内存
   #     print(line)

2.集合

#!/usr/bin/env python
# coding:utf-8
# Author:Yang

list_1 = [1,4,5,7,3,6,7,9]

list_1=set(list_1) # 变为集合 可以去重
print(list_1,type(list_1))

list_2 = set([2,6,0,66,22,8,4])
print(list_1,list_2)
# inrwesection 交集
print(list_1 & list_2)
print(list_1.intersection(list_2))
# 并集
print(list_1 | list_2)
print(list_1.union(list_2))
# 差集
print(list_1 - list_2) # 在1不在2
print(list_1.difference(list_2))
# 子集
list_3 = set([1,3,7])
print(list_3.issubset(list_3))
print(list_1.issuperset(list_3)) # 父集

# 对称差集
print(list_1 ^ list_2)
print(list_1.symmetric_difference(list_2)) # 并集-交集 symmetric 对称

list_4 = set([5,6,8])
print(list_3.isdisjoint(list_4)) # 判断没有交集为true

# 没有插入只能添加
list_1.add(999)
print(list_1)
# 添加多项
list_1.update([99,11])
print(list_1)

# 删除
list_1.remove(1)
print(list_1)

# 长度 len(list_1)

# 判断成员

1 in list_1
1 not in list_1

3.字符串编码与转码
encode:编码就是将字符串转换为字节码，涉及到字符串的内部表示
decode:转码就是将字节码转换为字符串，是将比特位显示为字符
在所有环境下进行转码，列如utf8转gbk,都必须先decode为unicode再encode为gbk
为什么呢？
(注意：1.pyhton3 所有都是默认存的unicode。
pyhton3中头部定义的utf-8只是程序文件文本的编码。
2.因为unicode是集合了基本上所有语言的字符编码（ascii的扩展编码），想要转换都必须先decode为unicode再encode为目标编码
3.在python3中，encode后不但是转换了编码，并且还转换为byte类型。
)
例如：
一个字符串是utf-8,先encode转为二进制，再decode为unicode,在encode为gbk,这个时候这个字符串是gbk的编码，并且是一个byte类型，在将文本改为gbk编码的时候便能看到这个字符串编码后的内容。

#!/usr/bin/env python
# coding:utf-8
# Author:Yang

import sys

print(sys.getdefaultencoding())
s = "你好" # 在这里 以上设置的utf-8只是文件编码，在python里所有都是用的unicode ,所以这里是unicode编码
s_to_gbk=s.encode("gbk")
print(s_to_gbk)  # gbk
print(s.encode()) # utf8

gbk_to_utf8=s_to_gbk.decode("gbk").encode("utf-8")   # 在python3中，encode不但转了编码还转换为byte类型
utf8_to_gbk=s.encode().decode("utf-8").encode("gbk")    # 转码 先decode转为unicode  在这里unicode以byte类型显示 然后再ecode为gbk
print(gbk_to_utf8)
print(utf8_to_gbk)

# 字符串转字节码 encode 编码
# 字节码转字符串 decode  解码

4.编程范式
（1）函数编程
（2）函数式编程（只要输入是确定的，输出就是确定的，函数内部没有逻辑判断，代表语言，erlang）
（3）.面向对象

函数与过程的区别
``

#!/usr/bin/env python
# coding:utf-8
# Author:Yang


# 函数
def func1():
    print('in the func1')
    return 0
# 过程    相当于没有返回值的函数
def func2():
    print('in the func2')


x=func1()
y=func2()

5.编程思想
面向对象和面向过程
6. 函数的参数

*args 是接收n个位置参数，转换为元组的形式
**kwargs 是接收n个关键字参数，转换为字典的形式
不管是定义函数的参数还是调用函数传入实参的时候，位置参数都必须在关键字参数之前。
在定义函数里的函数为形参，在调用函数时传入的函数为实参

#!/usr/bin/env python
# coding:utf-8
# Author:Yang

def test(*args): # 接收n个位置参数，转换为元组的形式
    print(args)

test(1,2,3,4,6)
test(*[1,2,3,4,5]) # *args=*[1,2,3,4,5]=
                   # 相当于 args = tuple([1,2,3,4,5])

def test1(x,*args):
    print(x)
    print(args)

test1(1,2,3,4,5,6,6,7)


# **kwargs  接收n个关键字参数转换为字典的方式
def test2(**kwargs):
    print(kwargs)
    print(kwargs['name'])
test2(name='yang',age=8,sex='F')
test2(**{'name':'yang','age':'12'})

def test3(name,**kwargs):
    print(name)
    print(kwargs)
test3('yang',age=18,sex='a')

def test4(name,age=18,**kwargs): # 参数组一定要往后放
    print(name)
    print(age)
    print(kwargs)

test4('yang',hobby='tesla')
test4('yang',hobby='tesla',age=4)
test4('yang',3,hobby='tesla')

def test5(name,*args,age=18,**kwargs):
    print(name)
    print(age)
    print(args)
    print(kwargs)


test5('yang',3,age=4,hobby='tesla')   # 位置参数必须在关键字参数之前

7.局部变量全局变量
只有集合，列表，字典能够改全局变量，字符串、常量是不能改全局变量的（元组本身就不能改）

#!/usr/bin/env python
# coding:utf-8
# Author:Yang
school="yhr" # 全局变量
names=["y","h","r"]
def chang_name(name):
    global school
    school = "yhr123"
    print('before change',name,school)
    name = 'yang' # 这个函数就是这个变量的作用域
    print('after change',name)
    names[0]="x"
    print("names:",names)

name = 'y' # 全局变量
chang_name(name)
print(name)
print(school)
print(names)  # 只有集合，列表，字典能够改全局变量，字符串、常量是不能改全局变量的（元组本身就不能改）
# 禁止以下写,容易导致逻辑混乱，不好调试，每一次调用都会改全局变量
# def change_name():
#     global name  # 可以变成全局变量，如果之前有就代替以前的全局变量
#     name="y"
#
# change_name()
# print(name)

8.高阶函数

#!/usr/bin/env python
# coding:utf-8
# Author:Yang


def add(a,b,f):
    return f(a)+f(b)

res=add(3,-6,abs)
print(res)

9.递归函数
递归函数特性:
1.必须要有约束条件
2.每进入一层，问题规模要减少
递归效率不高，递归层次增多后，会导致栈溢出（函数是栈式存储的，每进行一次函数调用，3.增加一层栈帧，每返回一次值，减少
一层栈帧，由于栈不是无限大在内存中，当次数过多时，会导致栈溢出）

#!/usr/bin/env python
# coding:utf-8
# Author:Yang


#递归函数特性:
# 必须要有约束条件
# 每进入一层，问题规模要减少
# 递归效率不高，递归层次增多后，会导致栈溢出（函数是栈式存储的，每进行一次函数调用，增加一层栈帧，每返回一次值，减少
# 一层栈帧，由于栈不是无限大在内存中，当次数过多时，会导致栈溢出）
def cal(n):

    print(n)
    if int(n/2) > 0:
        return cal(int(n/2))
    print("->",n)

10.匿名函数

def func(x,y):return x+y

#相当于
lamda x,y:x+y

老男孩14期自动化运维day3随笔和作业

猜你喜欢