1、字符编码

#ASCII码里只能存英文和特殊字符 不能存中文 存英文占1个字节 8位
#中文编码为GBK 操作系统编码也为GBK
#为了统一存储中文和英文和其他语言文字出现了万国码Unicode 所有一个字符都占2个字节 16位
#英文文档改为Unicode编码大小变大一倍 为解决这种浪费空间问题
#出现了Unicode扩展集 Utf-8 为可变长的字符编码 默认英文字符按ASCII码存储 中文按照3个字节存储

编码都要先decode成unicode再转码成目标编码

#获取默认编码
import  sys
print(sys.getdefaultencoding())

#文件头声明编码

#-*- coding:gbk -*-

#文件转码都要先转换成Unicode再转换成目标编码
#转换成Unicode时需要decode("自身编码")  并且传入自身编码即可以转换成unicode
#再转换成目标编码时 要encode("目标编码")

#ptyon3里 encode的时候不仅转换了编码 还变成了bits

s="你好"
#转换成gbk编码
s_gbk=s.encode("gbk")
print(s_gbk)
#gbk转换成utf-8
s_utf8=s_gbk.decode("gbk").encode("utf-8")
print(s_utf8)

#utf-8转换为gb2312
s_gb2312=s.encode("gb2312")
print(s_gb2312)

#gb2312转换为gbk
s_gbk2=s_gb2312.decode("gb2312").encode("gbk")
print(s_gbk2)

#gb2312转换为utf-8
s_utf8_2=s_gb2312.decode("gb2312").encode()
print(s_utf8_2)

print(s.encode("utf-8").decode("utf-8").encode("gb2312").decode("gb2312"))

#gbk向下兼容gb2312和gb23180

2、函数

1)函数定义

#定义函数的方法
def test(x):
    '''the fuction definition'''
    x=1
    return x

def 定义函数关键字
test 函数名
() 内可定义形参
"" 文档描述(非必要，但是强烈建议为你的函数添加描述信息)
x=x+1 泛指代码块或程序处理逻辑
return 定义返回值

2)函数和过程的区别

#面向对象 --> 类--> class
#面向对象 -->过程 --> def
#函数式编程-->函数-->def

#定义函数 有返回值
def fun1():
    print("in the fun1")
    return 0

#定义过程  没有返回值 程序默认返回None
def fun2():
    '''test1'''
    print("in the fun2")

x=fun1()
y=fun2()

print("from func1 return is %s" % x)
print("from func2 return is %s" % y)

3) 返回值

#函数返回值  是整个函数执行的结果 可以是任意值
#数字 字符 列表 字典 方法

# 返回None
def test1():
    print("test1")
#返回 0
def test2():
    print("test2")
    return  0

#返回 1,"123",[1,2,3],{"11":"22","33":"44"}
def test3():
    print("test3")
    return  1,"123",[1,2,3],{"11":"22","33":"44"}

#返回方法
def test4():
    print("test4")
    return  test1()

4）函数参数及调用

形参：往方法里传入的参数 位置参数
实参：实际存在于内存空间的
形参与实参一一对应

def test(x,y): #x,y形参
    print(x)
    print(y)

test(1,2) #1,2 实参数

#位置参数调用：按顺序匹配形参和实参
test(1,2)
#关键字调用： 指定形参和实参的对应关系,与形参顺序无关
test(y=1,x=2)
#Error 位置参数调用不能和关键字调用混合调用
#混合用会按照位置参数来
#test(x=2,4)
#OK 关键字参数一定要在位置参数后
test(3,y=4)

#默认参数 :定义方法的时候给形参一个默认值
#特点：调用的时候 默认参数非必传
#用途：
def test1(x,y=2):
    print(x)
    print(y)

test1(1)
test1(2,3)

#参数组(*args) 可接收多个位置参数转换为元组
#*表示个数不固定 args为形参数名
def test(*args):
    print(args)

test(1,2,3)
test("111")
#输出 (1, 2, 3, 4, 5)
test(*[1,2,3,4,5])
#输出([1, 2, 3, 4, 5],)
test([1,2,3,4,5])

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

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

#接收字典 **kwargs 接收多个关键字参数转化为字典

def test3(**kwargs):
    print(kwargs)
    print(kwargs["name"])
    print(kwargs["age"])

#输出 {'name': '111', 'age': '20'}
test3(name='111',age='20',title="it")
test3(**{"name":"22","age":"18"})

#可扩展参数方法
def test4(name,age=18,*args,**kwargs):
    print(name)
    print(age)
    print(args)
    print(kwargs)
# test4("anne",age="18",sex="m")
# test4("lily",sex="f")
#不能写test4("alex",age=20,30,40,hobby="llll")
test4("alex",20,30,40,hobby="llll")

5)局部变量与作用域

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

#局部变量：name 只在方法change_name里生效
#change_name就是name的作用域
def change_name(name):
    print("befor change %s " %  name)
    name="Alex"
    print("after change %s " % name)

name="alex"
change_name(name)
print(name)

#全局变量：在文件*定义的变量
#全局变量:数字、字符串、元组在函数里是改不了 。其他都可以改
#如果一定要在方法里改 在用之前加上golbal 也是可以改的
school="Oldboy edu."
def test1():
    global school #可以改了
    school="alex"
    print(school)
test1()
print(school)

names=["Anne","Joe","Sue"]
def test2():
    names[0]="Anne1"
    print(names)
test2()

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

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

#递归例子
def calc(n):
    print(n)
    if int(n/2)>0:
        return calc(int(n/2))
    else:
        return n

calc(10)

7) 函数式编程

8)高阶函数

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

#高阶函数例子
def add(a,b,f):
    return f(a)+f(b)
#abs 内置函数 求绝对值
print(add(3,-6,abs))