python学习Day3第二部分

学习简述：字符编码，函数

字符编码主要进行unicode，utf-8, gbk之间的转换

#字符编码 很重要！！
s = "你好"
print(s)

s_to_utf8 = s.encode('utf-8')
print (s_to_utf8)

w = s_to_utf8.decode('utf-8').encode('gbk')
print(w)

a = w.decode('gbk').encode('gb2312')
 

1. py3里默认文件编码就是utf-8,所以可以直接写中文，也不需要文件头声明编码了.
2. 你声明的变量默认是unicode编码，不是utf-8, 因为默认即是unicode了（不像在py2里，你想直接声明成unicode还得在变量前加个u）, 此时你想转成gbk的话，直接my_str.encode("gbk")即可以.
3. 但py3里，你在my_str.encode("gbk")时，感觉好像还加了一个动作，就是encode的数据变成了bytes了，这是怎么个情况，因为在py3里，str and bytes做了明确的区分，你可以理解为bytes就是2进制流，你会说，我看到的不是010101这样的2进制呀， 那是因为python为了让你能对数据进行操作而在内存级别又帮你做了一层封装，否则让你直接看到一堆2进制，不能看出哪个字符对应哪段2进制。

函数：

编程语言中函数的定义：函数是逻辑结构化和过程化的一种编程方法

编程方法有三种，分为：1)面向对象          特征：类     定义：class

                                     2)面向流程          特征：过程   定义：def

                                     3)函数式编程       特征：函数   定义：def

函数的优点：1.代码重用  2.保持一致性  3.可扩展性

def test(x):
     'the function definations'
     x +=1
     return x

def:定义函数的关键字
test：函数名
（）：内可定义形参
‘’：文档描述，（不必要，但是方便别人阅读）
x+=1：泛指代码块或程序处理逻辑
return：定义返回值

思考？为什么要有返回值：有些时候需要函数执行完的结果，后面需要根据不同的返回值进行不同的操作，比如正确返回True,错误返回False.

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

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

位置参数

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

#实参的数目不固定
def test(*args):    #  *代表args接受的参数是不固定的
    print(args)


test(1,2,3,4,5)
test(*[1,2,3,4,5])  # *args = *[1,2,3,4,5]

# *args:接受N个位置参数，转换成元组的形式
def test1(x,*args):
    print(x)
    print(args)

test1(1,2,3,4,4)

#>>>1
#   (2, 3, 4, 4)


# **kwargs:接受N个关键字参数，转换成字典的方式
def test2(**kwargs):
    print(kwargs)

test2(name='niu',aga=22)
#>>>{'name': 'niu', 'aga': 22}
test2(**{'name':'niu','age':'22'})

#也可以直接输出值
def test3(**kwargs):
    print(kwargs)
    print(kwargs['name'])
    print(kwargs['age'])
test3(name='niu',age=22)

def test4(name,**kwargs):
    print(name)
    print(kwargs)

test4('niu',age = 22,job = 'student')

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

test5('niu',age=22,job='student',iq ='150')

局部变量和 全局变量

job = 'student'   #全局变量
def change_name(name):
    global  job            # 把局部变量改为全局变量
    job = 'programmmer'
    print('before name',name,job)
    name = 'NIU'                  # 这个函数就是这个变量的作用域，name就是一个局部变量
    print('after change',name)

name = 'niu'
change_name(name)
print(name)
print(job)

names = ['niu','Jack','rain']
def change_name():
    names[0] = 'July'
    print('inside func',names)

change_name()
print(names)
列表，集合，字典，类都可以改

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。

全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。
小结
（1）变量查找顺序：LEGB，作用域局部>外层作用域>当前模块中的全局>python内置作用域
（2）只有模块，类，及函数才能引入新作用域
（3）对于一个变量，内部作用域先声明就会覆盖外部变量，不声明直接使用，就会使用外部作用域的变量。
（4）内部作用域要修改外部作用域变量的值时，全局变量要使用global关键字，嵌套作用变量要使用nonlocal关键字，是3新加的关键字。

递归

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

递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

def calculate(n):
    print(n)
    if int(n/2) >0:
        return calculate(int(n/2))
    print('-->',n)

calculate(10)

函数式编程介绍

输入是确定的，那么输出也是确定的

高阶函数

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

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

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

函数名可以进行赋值

函数名可以作为函数参数，还可以作为函数的返回值

内置函数

abs()        取绝对值
all()        所有元素都为真，则为真
any()        任一数据为真，则为真
ascii()      将内存的数据对象打成字符串的形式
bin()         将十进制转为二进制
bool()        判断真假
bytearray()   可修改的二进制字节格式
chr()         把数字对应的Ascii打出来<<<chr(97)  'a'
ord()         把Ascii字符输出成数字
exec()        把字符串转换成代码
compile()     复数
dir()         查看所有的方法
divmod        返回商和余数
eval()        把字符串变成字典
exec()        复杂的字符串打印出来
filter()      用于过滤
map()         对传入的每个值进行处理
frozenset()   冻结
hash()        进行快速查找
hex()         转为16进制
oct()         转为8进制
round()       保留几位
slice()       切片
sorted()      将一个字典变为有序的列表
zip()         把两个列表变成一一对应的一个个小元组的形式,不一样长时，按小的那个来
__import__()
a = bytes('abcde',encoding ='utf-8')
print(a)
#>>>b'abcde'
b = bytearray('abcde',encoding ='utf-8')
b[1] = 100
print(b)
#>>>bytearray(b'adcde')

c = chr(97)
print(c)

def sayhi(n):
    print(n)
sayhi(3)

cala = lambda n:print(n)    #lamba处理不了for循环
cala(5)

f = filter(lambda n:n>5,range(10))
for i in f:
    print(i)
res = map(lambda n:n*2,range(10))
for i in res:
    print(i)

a={6:2,8:0,1:4,-5:6,99:11,4:22}
print(sorted(a.items()))     #按key
print(sorted(a.items(),key = lambda n:n[1]))  #按键
print(a)

a = [1,2,3,4]
b = ['a','b','c','d']
for i in zip(a,b):
    print(i)
#>>>(1, 'a')
#>>(2, 'b')
#>>(3, 'c')
#>>(4, 'd')

#几个重要内置函数
#filter
str = ['a','b','c','d']
def f(n):
    if n!='a':
        return n
f = filter(f,str)
print(set(f))
#>>>{'c', 'b', 'd'}

#map
str = ['a','b','c','d']
def fun(n):
    return n+'hello'
m = map(fun,str)
print(list(m))
#>>>['ahello', 'bhello', 'chello', 'dhello']

#reduce
from functools import reduce
def add1(x,y):
    return x+y
print(reduce(add1,range(1,101)))
#>>>45
def jiecheng(a,b):
    return a*b
print(reduce(jiecheng,range(1,6)))
#>>>120

#lambda
from functools import reduce
print(reduce(lambda a,b :a*b,range(1,6)))
#>>>120