day_3_python

1.上一作业，在while中退出程序

exit("bye......")

2.字符编码的再次学习

a.编码发展史
ascii 1960 -----> gb2312 1980 6700 ----> gbk 1995 21000 -----> gb18030 27000 2000

ascii 1960 -----> 1991 unicode 32= 4bytes -----> unicode 16 -----> 经过优化，就是现在主流的 utf-8

b.windows下的字符的显示
你能看到的任何东西都是经过编码（转化的）后，才能看到的
windows操作系统，在各个国家使用该国家的默认字符编码集，到内存里都是unicode，显示到屏幕转换成gbk
windows命令行里，命令行默认支持unicode，默认不支持日文
windows默认编码gbk，默认可支持unicode and gbk

依然有很多国家,在使用自己的编码，中国的gbk 日本的QR 直接更改系统编码，太麻烦了
中国和日本 翻译是英文 日文 QR---- （英语） unicode-----汉语 GBK

c.python2.X与python3.X的区别
python 2.x 默认编码是ascii
#-*- coding:utf-8 -*- 告诉py的解释器，我后面的这段代码请用utf8来解释
>>> import sys
>>> sys.getdefaultencoding()
'ascii'

#-*- coding:utf-8 -*-

msg = "中国"

print msg

gbk_str = msg.decode(encoding="utf-8").encode(encoding="gbk")   #decode 告诉python解释器现在的编码，不说就报错
print [gbk_str,]
#erjinzhide biaoxianxingshi
print gbk_str.decode(encoding="gbk").encode(encoding="gb2312")
print gbk_str.decode(encoding="gbk").encode(encoding="utf-8")
print [gbk_str.decode(encoding="gbk"),]

python3.X默认编码utf-8 解释器就是unicode

硬盘上文件编码就是utf-8，加载到内存里就是unicode，代码加载到内存里，自动转化成unicode
要转换成gbk，只需要编码成gbk

msg = "中国"   #unicode格式

print(msg.encode(encoding="gbk"))
print(msg)

默认文件编码是uft-8 ，解释器编码是unicode，文件加载到内存后会自动解码成unicode，

同时把字符转换成bytes格式

bytes = 8bits 就相当于二进制格式

现在默认在内存里跑的都是unicode，所有的语言都是unicode方式打开的
转成bytes格式，是为了存文件，编码成gbk格式，另一个机器可以直接读取

显示bytes的原因，方便我们操作是编码和二进制的中间状态
变成bytes格式的方法：1.encode “中国”.encode("gbk") 2.b"abc"

python2里的str 2里的bytes= python3 的bytes
python3 str = unicode
python3 多出来的bytes的格式是一个独立的数据类型

d.总结：

py2在windows上解码是必须的，编码成gbk这个动作不是必须的
py2在linux上，如果gbk--->utf-8解码上必须的，编码成utf-8不是必须的
python3.X解决了真正实现了所有国家的语言，都可使用一个编码unicode

在py3中encode,在转码的同时还会把string 变成bytes类型，decode在解码的同时还会把bytes变回string
所有的程序在内存里默认都是unicode，编码都不是必须的，
只有存储到硬盘上，才需要编码

e.用途：爬虫

3.文件操作的再学习

open() encoding 不声明 默认使用操作系统的编码来解释文件

r w a
r+ 可读 +追加，可以定长修改

f = open("lyrics","r",encoding="utf-8")
print("cursor:",f.tell())
f.seek(10)
print("cursor:",f.tell())
print(f.read(5))

print(f.read())

print("cursor:",f.tell())
print("--------------------------")

print(f.read())
print("cursor:",f.tell())

f.close()

a:只能追加

w+ 清空原文件内容，再写入新内容

f = open("lyrics","w+",encoding="utf-8")
print("cursor:",f.tell())
f.write("sddddd")
f.write("昨天当我年少轻狂")
f.seek(0)
print(f.read())

f.write("--------------")

f.close()

a+ 追加+读

f = open("lyrics", "a+", encoding="utf-8")

f.write("杨戬，真帅！！")

f.seek(0)
print(f.read(100))

f.close()

f.seek(10) 代表移动10个字节，

f.read(6) 代表移动6个字符

rb: 以二进制模式打开文件，不能声明encoding
wb: 以二进制写入文件，必须写入bytes格式

print(ord("c"))

a = bytes("abc",encoding="utf-8")
print(a[0])

b = bytes("中国",encoding="utf-8")
print(b[0])

f = open("lyrics","wb")

f.write("哈sdfad哈".encode("gbk"))

f.close()

python程序都是通过操作系统，调用操作系统的接口，就可以打开文件

操作系统维护着的文件的列表 ---文件描述符
seek只用于文本文件
flush()

3.集合

通过hash，只存储hash的值，值的唯一的
1.去重 2.无序（既是无索引）3.关系运算

a = {1,3,5,7,10}
b = {2,3,4,5,6,8}
print(a & b)  #交集
print(a.intersection(b))
print(b - a)  #差集
print(a - b)
print(a.difference(b))
print(a | b)  #并集
print(a.union(b))
print(a ^ b)  #对称差集
print(a.symmetric_difference(b))
# a.intersection_update(b)
# print(a)
print(a.issubset(b))
print(a.issubset(b))

4.函数

a.定义：函数是值将一组语句的集合通过一个名字（函数名）封装起来，要想执行这个函数，只需调用其函数名即可

既是把重复代码提取出来，放到一个公共的地方

b.函数特性

*.    减少重复代码
**.  使程序变得可扩展
***.使程序变得易维护

def sayhi(name):
    print("Hello,i'm %s!!" %name)

sayhi("alex")
sayhi("gaohui")

c.函数返回值

要想获取函数的执行结果，就可以用return语句把结果返回，只能返回一个值，如果是多个值就要把他们放在元组里

注意:

*.  函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束

**.如果未在函数中指定return,那这个函数的返回值为None 

def sayhi(name):
    print("Hello,i'm %s!!" %name)

sayhi("alex")
sayhi("gaohui")

a =10
b = 15
c = a ** b
print(c)

def calc(a,b):
    #print(a ** b)
    return a ** b

c = calc(a,b)
print(c)

def change(n):
    print(n)    #引用的全局变量
    n = "changed by func"    #局部变量，作用域在函数内部
    print(n)

n = "test"    #全局变量
print(n)
change(n)
print(n)

def change():
    print(names)
    names[0] = "Mack"      #引用的是内存地址
    names.append("rain")
    info["age"] = 22

names = ["alex","jack"]
info = {"name":"rain"}
change()
print(names,info)

d.函数参数

形参：临时变量，占位符

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

实参：真正存在的值 有确定值的参数

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

def stu_register(name,age,cource,country="CN",*args,**kwarges):
    print("----注册学生信息----")
    print("姓名：",name)
    print("age",age)
    print("国籍：",country)
    print("cource:",cource)
    print(args, kwarges)
    print(args,kwarges["hobby"])
stu_register("alex",22,"python","JP","IT","shandong",hobby="travel",addr = "liaocheng")
#stu_register(age=22,name="rain",cource="yunwei")
#stu_register("jack",23,"CN","yunwei")

位置参数　　按顺序

默认参数　　必须在为位置参数的后面

关键参数　　必须在为位置参数的后面

非固定参数

　　*args=(),以位置参数的形式传入，**kwargs={}，以关键参数的形式传入

e.局部变量

作用域只在当前函数内部，外部变量默认不能被函数内部修改，只能引用全局变量

如果想在函数里修改全局变量，必须global，但是强烈建议不要这么做

函数内部是可以修改列表，字典，集合，实例的，更改的是里面某个元素的地址 --就相当于是房间号和里面的东西的关系

全局与局部变量

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

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

当全局变量与局部变量同名时：

在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

f.嵌套函数

name = "alex"

def change_name():
    name = "alex2"

    def change_name2():
        name = "alex3"
        print("three-laywer",name)

    change_name2()
    print("second-laywer",name)

change_name()
print("second-laywer",name)

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

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

***.递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，

每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，

所以，递归调用的次数过多，会导致栈溢出）

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

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

def calc(n,count):
    print(n,count)
    #if int(n/2) > 0:
    n = calc(int(n/2),count+1)
    print(n)
    return n

print(calc(10,1))

递归函数的具体应用：二分查找

#data = [1,2,4,6,7,8,9,11,14,16,18,19,20,22,25,29]
data = range(20,10000000000000,2)
def binary_find(find_num,data_set):
    mid =int(len(data_set)/2)
    if mid == 0:
        if data_set[mid] == find_num:
            print("find it finally",find_num)
        else:
            print("can't find this number in list! ",find_num)
        return
    if data_set[mid] == find_num:
        print("you find it.....")
    elif data_set[mid] > find_num: #find_num in the left
        print(data_set[0:mid],mid)
        binary_find(find_num,data_set[0:mid])
    else: #find_num in the right
        print(data_set[mid+1:],mid)
        binary_find(find_num,data_set[mid+1:])
binary_find(21,data)

h.匿名函数　　支持的最复杂的运算就是三元运算

calc = lambda n,y: n**y
print(calc(10,13))

for i in map(lambda x:x*2,[1,2,3]):
    print(i)

for i in map(lambda x:x*x if x > 5 else x -1,[1,2,3,4,5,6,7,8,9]):
    print(i)

i.高阶函数

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


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

*.  把一个函数的内存地址当做参数传给另外一个函数

**.一个函数把另外一个函数当做返回值返回