python自动化之路 day3 py基础3

 

重点回顾

1.集合

主要作用:
● 去重
● 关系测试， 交集＼差集＼并集＼反向(对称)差集

2.元组

只读列表，只有count, index 2 个方法
作用：如果一些数据不想被人修改， 可以存成元组，比如身份证列表

3.字典

key-value对特性：
● 无顺序
● 去重
● 查询速度快，比列表快多了
● 比list占用内存多
为什么会查询速度会快呢？因为他是hash类型的，那什么是hash呢？

哈希算法将任意长度的二进制值映射为较短的固定长度的二进制值，这个小的二进制值称为哈希值。哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该段落的一个字母，随后的哈希都将产生不同的值。要找到散列为同一个值的两个不同的输入，在计算上是不可能的，所以数据的哈希值可以检验数据的完整性。一般用于快速查找和加密算法

dict会把所有的key变成hash 表，然后将这个表进行排序，这样，你通过data[key]去查data字典中一个key的时候，python会先把这个key hash成一个数字，然后拿这个数字到hash表中看没有这个数字， 如果有，拿到这个key在hash表中的索引，拿到这个索引去与此key对应的value的内存地址那取值就可以了。

4.字符编码

在python2中：
1. py2里默认编码是ascii
2. 文件开头那个编码声明是告诉解释这个代码的程序 以什么编码格式 把这段代码读入到内存，因为到了内存里，这段代码其实是以bytes二进制格式存的，不过即使是2进制流，也可以按不同的编码格式转成2进制流，你懂么？
3. 如果在文件头声明了#_*_coding:utf-8*_，就可以写中文了， 不声明的话，python在处理这段代码时按ascii，显然会出错， 加了这个声明后，里面的代码就全是utf-8格式了
4. 在有#_*_coding:utf-8*_的情况下，你在声明变量如果写成name=u"大保健"，那这个字符就是unicode格式，不加这个u,那你声明的字符串就是utf-8格式
5. utf-8 to gbk怎么转，utf8先decode成unicode,再encode成gbk
在python3中：
1. py3里默认文件编码就是utf-8,所以可以直接写中文，也不需要文件头声明编码了，干的漂亮
2. 你声明的变量默认是unicode编码，不是utf-8, 因为默认即是unicode了（不像在py2里，你想直接声明成unicode还得在变量前加个u）, 此时你想转成gbk的话，直接your_str.encode("gbk")即可以
3. 但py3里，你在your_str.encode("gbk")时，感觉好像还加了一个动作，就是就是encode的数据变成了bytes里，我擦，这是怎么个情况，因为在py3里，str and bytes做了明确的区分，你可以理解为bytes就是2进制流，你会说，我看到的不是010101这样的2进制呀， 那是因为python为了让你能对数据进行操作而在内存级别又帮你做了一层封装，否则让你直接看到一堆2进制，你能看出哪个字符对应哪段2进制么？什么？自己换算，得了吧，你连超过2位数的数字加减运算都费劲，还还是省省心吧。　　
4. 那你说，在py2里好像也有bytes呀，是的，不过py2里的bytes只是对str做了个别名(python2里的str就是bytes, py3里的str是unicode)，没有像py3一样给你显示的多出来一层封装，但其实其内部还是封装了的。 这么讲吧， 无论是2还是三， 从硬盘到内存，数据格式都是 010101二进制到-->b'\xe4\xbd\xa0\xe5\xa5\xbd' bytes类型－－>按照指定编码转成你能看懂的文字

1. 函数基本语法及特性

程序范式

● 面向对象：华山派---》 类 ---》 class
● 面向过程：少林派 ---》 过程 ----》 def
● 函数试编程：逍遥派 --》 函数 ---》 def
函数是什么?
函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，具体区别，我们后面会讲，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可

函数特性

1. 减少重复代码
2. 使程序变的可扩展
3. 使程序变得易维护

语法定义：

def sayhi():#函数名
print("Hello,World!!")

sayhi() #调用函数

可以带参数
#下面这段代码
a,b = 5,8
c = a**b
print(c)


#改成用函数写
def calc(x,y):
res = x**y
return res #返回函数执行结果

c = calc(a,b) ＃结果赋值给c变量
print(c)

2.函数参数与局部变量　

形参：只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量。

实参：可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

#改成用函数写
def calc(x,y):    #这里的x，y 即为 形参
res = x**y
return res #返回函数执行结果

c = calc(a,b) #这里的a，b即为实参
print(c)

默认参数

看下面代码
def stu_register(name,age,country,course):
print("----注册学生信息------")
print("姓名:",name)
print("age:",age)
print("国籍:",country)
print("课程:",course)

stu_register("王山炮",22,"CN","python_devops")
stu_register("张叫春",21,"CN","linux")
stu_register("刘老根",25,"CN","linux")

发现 country 这个参数 基本都 是"CN", 就像我们在网站上注册用户，像国籍这种信息，你不填写，默认就会是 中国， 这就是通过默认参数实现的，把country变成默认参数非常简单
def stu_register(name,age,course,country="CN"):
这样，这个参数在调用时不指定，那默认就是CN，指定了的话，就用你指定的值。

另外，你可能注意到了，在把country变成默认参数后，我同时把它的位置移到了最后面，为什么呢？

关键参数

正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可，但记住一个要求就是，关键参数必须放在位置参数之后。

stu_register(age=22,name='alex',course="python",)

非固定参数

若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数

def stu_register(name,age,*args): # *args 会把多传入的参数变成一个元组形式
print(name,age,args)

stu_register("Ljohn",22)
#输出
#Ljohn 22 () #后面这个()就是args,只是因为没传值,所以为空

stu_register("Jack",32,"CN","Python")
#输出
# Jack 32 ('CN', 'Python')

还可以有一个**kwargs
def stu_register(name,age,*args,**kwargs): # *kwargs 会把多传入的参数变成一个dict形式
print(name,age,args,kwargs)

stu_register("Ljohn",22)
#输出
#Ljohn 22 () {}#后面这个{}就是kwargs,只是因为没传值,所以为空

stu_register("Jack",23,"CN","Python",sex="Nale",hobbly="Girl")
#输出
# Jack 23 ('CN', 'Python') {'sex': 'Nale', 'hobbly': 'Girl'}

局部变量

name = "Ljohn"

def change_name(name):
print("before change:" ,name)
name = "Mr Liu"
print("after change",name)

change_name(name)

print("在外面看看name改了么?",name)

输出：
before change: Ljohn
after change Mr Liu
在外面看看name改了么? Ljohn

 

全局与局部变量

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
当全局变量与局部变量同名时：
在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

 

3.返回值

要想获取函数的执行结果，就可以用return语句把结果返回
注意:
1. 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
2. 如果未在函数中指定return,那这个函数的返回值为None

4.递归

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

def calc(n):
print(n)
if int(n/2) == 0:
return n
return calc(int(n/2))

calc(100)

输出：
50
25
12
6
3
1

递归特性：
1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

递归函数实际应用案例，二分查找

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]

def binary_search(dataset,find_num):
print(dataset)

if len(dataset) >1:
mid = int(len(dataset)/2)
if dataset[mid] == find_num: #find it
print("找到数字",dataset[mid])
elif dataset[mid] > find_num:# 找的数在mid左面
print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid])
return binary_search(dataset[0:mid],find_num)
else:# 找的数在mid右面
print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid])
return binary_search(dataset[mid+1:],find_num)
else:
if dataset[0] == find_num:#find it
print("找到数字啦",dataset[0])
else:
print("没得分了，要找的数字[%s]不在列表里" % find_num)

binary_search(data,3)

输出：
[1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
找的数在mid[18]左面
[1, 3, 6, 7, 9, 12, 14, 16, 17]
找的数在mid[9]左面
[1, 3, 6, 7]
找的数在mid[6]左面
[1, 3]
找到数字 3

5.匿名函数

如果函数值使用一次，并且结构结单（需要一行表达式），就可以使用匿名函数。匿名函数的好处：
1. 程序一次行使用，所以不需要定义函数名，节省内存中变量定义空间
2. 让程序更加简洁

普通函数：
def calc(x,y):
return x+y
print(calc(1,2))
匿名函数：
calc = lambda x,y:x+y
print(calc(1,2))
输出：
3

定义一个匿名函数（ambda）：
1. 冒号（:）：分隔符
2. 冒号之前的部分：函数的参数，可以无参数，但是冒号不能省
3. 冒号之后的部分：函数的返回值。lambda没有return，后面的就是返回值
4. 上面的列子我们还是定了一个变量名，因为方便后面给参数赋值，这样函数用完后并没有释放空间。把整个函数括起来，后面再写个括号写入参数。

print((lambda x,y:x+y)(1,2))

 

单单从上例，无法说明匿名函数真正价值，匿名函数的真正用途：主要是和其他函数搭配使用。

res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
print(i)
输出：
1
25
49
16
64

 

6.函数式编程

函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。

函数式编程定义
函数式编程中的函数这个术语不是指计算机中的函数（实际上是Subroutine），而是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其他状态。比如sqrt(x)函数计算x的平方根，只要x不变，不论什么时候调用，调用几次，值都是不变的。Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。

简单说，"函数式编程"是一种"编程范式"（programming paradigm），也就是如何编写程序的方法论。
主要思想是把运算过程尽量写成一系列嵌套的函数调用。举例来说，现在有这样一个数学表达式：
　　(1 + 2) * 3 - 4
传统的过程式编程，可能这样写：
　　var a = 1 + 2;
　　var b = a * 3;
　　var c = b - 4;
函数式编程要求使用函数，我们可以把运算过程定义为不同的函数，然后写成下面这样：

var result = subtract(multiply(add(1,2), 3), 4);

这段代码再演进以下，可以变成这样

add(1,2).multiply(3).subtract(4)

这基本就是自然语言的表达了。再看下面的代码，大家应该一眼就能明白它的意思吧：

merge([1,2],[3,4]).sort().search("2")

因此，函数式编程的代码更容易理解。

要想学好函数式编程，不要玩py,玩Erlang,Haskell, 好了，我只会这么多了。。。

 

7.高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

# Description:高阶函数

def add(x,y,f):
return f(x) + f(y)

res = add(3,-6,abs) #abs 内置函数取绝对值
print(res)

输出

9

 

8.内置函数

Built-in Functions

参考python3 官方的内置函数介绍：https://docs.python.org/3/library/functions.html?highlight=built#ascii

内置函数示例

abs() 取绝对值
print(abs(3),abs(0),abs(-9))

all() 一个可迭代对象，只有其中有个值都为True,就返回True
print(all([0,1,2,3,4,5])) #False
print(all([1,2,3,4,5])) #True

ascii()把一个对象变成一个可打印的字符串的形式，没什么用。
print(type(123),type(ascii(123)),ascii(123)) # int类型通过ascii()变成了str类型
print(ascii("你好")) # 中文字还会转码

bin()把一个整数转换成二进制
print(bin(8)) # 0b1000
bool()布尔，判断True还是False
print(bool(1))
print(bool([]))
print(bool([1,2,3]))
print(bool("你好"))
print(bool(None))
bytearray()变成一个bytearray格式

bytes()变成一个bytes格式
a = bytes("abcde",encoding="utf-8")
b = bytearray("abcde",encoding="utf-8")
print(type(a),type(b))
#a[1] = 99 # bytes类型是不可以修改的，str类型也是
b[1] = 99 # 这个可以修改
print(a,b)

callable() 判断一个对象是否可以被调用。函数名后面可以加()，加了()就是调用。是否可以被调用，就是是否可以后面加()
a = []
print(callable(a)) # Fales，列表不能被调用
def b():
pass
print(callable(b)) # True，函数可以被调用
c = ( i for i in range(10) )
print(callable(c.__next__)) # True，生成器c可以用next方法调用下一个元素
chr()返回这个整数对应的字符

ord()返回这个字符对应的字符的编码
print(chr(100))
print(ord("d"))
print(chr(8364)) # 是这个符号
print(chr(7)) # 这个会发出“嘟”的一声
classmethod(function)类方法，以后会讲

compile()把代码进行编译，大概是这样。我们用不到，给个了可以执行的演示。
把字符串形式的代码编译执行。
# 把你的代码转成字符串存在变量里
code = """
def fib(n):
i,a,b = 0,0,1
while i < n:
#print(b)
yield b
a,b = b,a+b
i += 1
return "结束"
f = fib(10)
while 1:
try:
x = next(f) # x = f.__next__()
print(x)
except StopIteration as e:
print("返回值是：",e.value)
break
"""
#exec(code) # 其实这里直接exec也是可以执行的
py_obj = compile(code,"","exec") # 编译你的代码，第二个参数是文件名存放编译过程中出错的信息
exec(py_obj) # 上面是用exec编辑的，这里用exec执行

这个例子并不是很好，把上面的那句注释掉的语句直接执行也是可以的，不需要经过compile的编译。但是也没有别的例子了，总之就是用不到。
这里为啥是exec，什么是exec，还能不能是别的，暂时不知道。

complex()生成复数
a = complex("1+2j") # 字符串转为复数
b = complex(1,2) # 两个参数都是数字，第一个为实部，第二个为虚部
print(type(b),b)
delattr()被略过了，以后会讲

dict()创建字典，其实可以用来生成很复杂的字典，比如用列表来构造
a = dict() # 创建一个空字典
print(type(a),a)
dir()查看对象有什么方法
a = {}
print(dir(a))
b = "123"
print(dir(b))
c = 123
print(dir(c))
不同的数据类型，能使用的方法是不用的。两个__下划线的是内部方法，一般都不能用，也有能用的，比如迭代器的__next__。

divmod(a,b)，a除以b，得到商和余数
print(divmod(9,5)) # (1,4)
print(divmod(10,4)) # (2,2)

enumerate()可以为元组或列表等生产索引序列
list1 = ['a','b','c','d','e']
for i,j in enumerate(list1):
print(i,j)

eval()把字符串形式的字典、列表等等，转换成对应的数据类型
a = "{'a':1,'b':2,'c':3}"
print(type(a),a)
b = eval(a)
print(type(b),b)

exec()，可以执行字符串形式的代码
comm = """
a = [1,2,3,4,5]
for i in a:
print(i)
"""
exec(comm)

filter(),根据参数1的函数对参数2进行过滤

map(),根据参数1的函数对参数2进行处理
res1 = filter(lambda n:n>6,range(10))
for i in res1:
print(i)
res2 = map(lambda n:n*2,range(10))
for j in res2:
print(j)

frozenset()，创建一个不可变的集合
a = set([1,2,3,4,5])
a.pop() # set可以从中增加或者删除元素
print(type(a),a)
b = frozenset([1,2,3,4,5])
#b.pop() # frozenset无法改变里面的元素
print(type(b),b)

globals()，返回全局变量的变量名和值，字典的形式。局部变量可以用locals()
print(globals())
getattr()，返回对象属性值，关于对象还没讲到，以后会讲，应该是很重要的内容

hasattr()，判断对象是否包含这个属性


setattr()，设置对象属性值，和上面的getattr相对应。

hash()，获取一个字符串或数值的哈希值
print(hash(123))
print(hash('123'))
print(hash('test'))
print(hash(str([1,2,3]))) # 列表不可以，需要转成字符串

help()，查看帮助
help('hash') # 查看hash函数的帮助
a = [] # a现在是一个列表
help(a) # 查看列表的帮助

hex()，把数字转成16进制
print(hex(15))
print(hex(1023))
print(hex(-256))
id()，返回内存地址
def a():
pass
print(a) # 这里直接打印函数的内存地址
print(hex(id(a))) # id默认是10进制，转成16进制和上面一样
input()，获取输入的字符串
a = input("输入任意字符串：")
print(a)
int()，转成10进制，默认输入的数据是10进制，或者用第二个参数指定
print(int('15')) # 默认10进制
print(int('10',16)) # 16进制的10就是10进制的16
print(int('0x10',16)) # 即时字符串前有0x，后面的16进制也不能省略
print(int('ff',16))
print(int('0b100',2))
print(int('100',5)) # 还可以有奇怪的进制，5进制
print(int('1gg',17)) # 17进制

isinstance()，判断参数1是否是参数2的类型
print(isinstance(1,str)) # False
print(isinstance('1',str)) # True
print(isinstance([],(set,dict))) # False，是否是元祖中的其中一个类型
print(isinstance([],(list,dict))) # True

issubclass()，是不是一个子类。啥是类，还没学

iter()，装换成迭代器
from collections import Iterator
a = [1,2,3,4,5,6] # a是列表
print(isinstance(a,Iterator)) # Fales，现在a还不是一个迭代器
b = iter(a) # 把a变成成迭代器
print(isinstance(b,Iterator)) # True，现在b是一个迭代器了
print(b.__next__()) # 可以用next
print(b.__next__())
print(b.__next__())

len()，返回长度
print(len('123'))
print(len([1,2,3]))

list()，可以将元祖转换成列表。只要是可迭代对象应该都可以
a = (1,2,3)
b = list(a)
print(type(a),a)
print(type(b),b)
print(range(10))
print(list(range(10))) # range()也可以转

locals()，打印当前位置的局部变量，字典的形式，变量名和值
def test():
local_var = 123
print(locals()) # 打印局部变量，只有一个local_var
print(globals()) # 打印的依然是全局变量，没有当前位置的局部变量
test()
print(locals()) # 这个位置打印的就是全局变量
print(globals()) # 打印的还是全局变量

map()，根据提供的函数，对指定的对象做映射
a = map(lambda x:x**2,[1,2,3,4,5]) # 列表中的每个元素都用lambda的方法计算一次
print(list(a))
max()和min()，返回最大值和最小值
print(max(1,2,3)) # 可以是好几个变量
print(min([1,2,3])) # 也可以是一个列表
memoryview()，返回给定对象的内存查看对象(Momory view)。不懂，也用不到。

next()，通过__next__()调用迭代器的下一项
a = ( (lambda x:x**2)(i) for i in range(2,10) ) # 构造一个迭代器
print(next(a)) # 打印出迭代器中的下一项
print(next(a))
print(next(a))
object，Python里，一切皆对象。至于这里有什么用，不知道

oct()，将整数转为8进制
print(oct(1))
print(oct(8))
print(oct(9))
print(oct(0xa)) # 这个是16进制的写法
open()，打开文件。之前用过很多了，略。

ord()，前面chr()一起讲了

pow()，求幂。其实可以有3个参数pow(x,y,z)，就是计算(x**y)%z，有z的情况下求余数。
print(pow(2,10,3)) # 2**10除以3的余数
print(pow(2,10)) # 求2的10次幂
print()，略

property()，返回新式类属性，以后会讲。

range()，直接看例子
print(list(range(10))) # 1个参数，从0开始
print(list(range(2,10))) # 2个参数：指定开始和结束
print(list(range(2,10,2))) # 3个参数：再加上步长
repr()，把对象转为字符串
a = [1,2,3,4,5]
b = repr(a)
print(type(a),a) # a是列表
print(type(b),b) # b是字符串
reversed()，对对象进行反转，返回的是一个迭代器
a = (1,2,3,4,5)
b = reversed(a)
print(next(b))
print(next(b))
print(list(b))
c = ['a','b','c','d','e']
d = reversed(c)
print(list(d))
round()，格式化浮点数。第一个参数是数值，第二个参数是小数位数。用字符串格式化的%f应该更方便，但是如果要用参数控制小数位数，应该只能靠round()

print(round(0.1234,2))
num = 0.1234567
for i in range(3,7):
print(round(num,i))
set()，创建集合
a = [1,2,3,4,5,2,3]
b = set(a)
print(type(b),b)
setattr()，设置对象属性值，和上面的getattr相对应。这个非常重要，以后会讲

arr = range(10)
print(arr[slice(2,8,2)])
print(arr[2:8:2]) # 和上面效果一样

sorted()，
a = {'c':5,'z':2,'a':4,'o':9,'f':8}
b = sorted(a.items()) # 按字典的key来排序
c = sorted(a.items(),key=lambda x:x[1]) # 按字典的value排序比较复杂
print(a) # 原来的字典
print(b) # 排序后，但是这里是列表了，因为字典是无序的
print(c) # 排序后，按照原来字典的value输出了

b=sorted(a.items(),key=lambda x:x[1])这句解释一下。sorted的第二个参数是指定排序的关键字。这里的key=是sorted函数的关键参数(不是字典的key)，就是按lambda x:x[1]的值进行排序。这里已经把字典的每一个元素变成一个元组了，参考b的输出。这里的x[1]就是元组的第二个元素，也就是字典的value值。所以就是按字典的value来进行排序了。

staticmethod()，是一个方法，以后会讲。
str()，转换成字符串。
sum()，求和
super()，非常重要的面向对象里的继承的概念，也要以后讲了。
tuple()，生成一个元组
type()，查看数据类型
print(type(1))
print(type('1'))
print(type(True))
print(type({}))
print(type([]))
print(type(()))

vars()，返回一个对象的所有的属性名和值，缺省参数就和locals()一样了。要加上对象才有别的效果。但是：1、对象还没学；2、还是用不到
class Runoob:
a = 1
def test():
a = 1
print(vars())
print(locals())
print("在函数内部，2个效果一样")
test()
print("作用于全局，2个效果还是一样")
print(vars())
print(locals())
print("vars可以带参数，指定一个class，主要是这个作用")
print(vars(Runoob))

zip()，把几个可迭代对象组合起来
a = [1,2,3,4]
b = ['a','b','c','d']
for i in zip(a,b): # 把两个可迭代对象组合起来
print(i)
c = ['A','B','C','D','E']
for i in zip(a,c): # 如果长度不一样，按短的来
print(i)
for i in zip(a,b,c): # 参数的数量不定
print(i)

__import__()，动态加载。一般用import加载模块就好了。如果一个模块经常变化就要使用 __import__() 来动态载入。