python函数

1.摘要

• 编码
• 文件
• 集合
• 函数
• 递归

2.编码

    unicode 32占用4个字节，unicode 16 = unicode 占用2个字节，utf-8可变长字符编码

    在python 2.x中默认的字符编码为ascii,(unicode后于python出现)

    #-*-coding:utf-8 -*- 2  #告诉py的解释器，后面的代码请用utf-8来解释 

 

    python 2.x和python 3.x的默认字符编码不同：  

Python 2.6.6 (r266:84292, Nov 22 2013, 12:16:22) 
[GCC 4.4.7 20120313 (Red Hat 4.4.7-4)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> 
>>> sys.getdefaultencoding()     #python 2.x中默认编码为ascii
'ascii'
>>> 


Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>>
>>> import sys
>>> sys.getdefaultencoding()   #python 2.x中默认编码为ascii
'utf-8'
>>>

 

    python 2.x的字符编码转换过程：

    

 

在python2操作如下：

#python 2.x中不能直接打印中文
msg = "中国"
print(msg)

E:\Python>python2 字符编码.py
File "字符编码.py", line 2
SyntaxError: Non-ASCII character '\xe4' in file 字符编码.py on line 2, but no encoding declared; see http://www.python.org/peps/pep-0263.html for details



#-*- coding:utf-8 -*-               #添加后为乱码
msg = "中国"
print(msg)

E:\Python>python2 字符编码.py #输出的为乱码
涓浗

 

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

msg = "中国"
print(msg)

print(msg.decode())

E:\Python\mytest\python2>python2 字符编码.py
涓浗
Traceback (most recent call last):
File "字符编码.py", line 6, in <module>
print(msg.decode())                                                  #decode解码，如果不指定汉字encoding编码格式，python 2.x解释器使用默认的ascii码进行解码
UnicodeDecodeError: 'ascii' codec can't decode byte 0xe4 in position 0: ordinalnot in range(128)

E:\Python>

 

 

#-*- coding:utf-8 -*-
msg = "中国"
print(msg)

#print(msg.decode())
print(msg.decode(encoding="utf-8").encode(encoding="gbk"))          #decode解码，如果不指定汉字encoding编码格式，python 2.x解释器使用默认的ascii码进行解码
                                                                    #encode编码，encoding指定编码成指定字符编码


E:\Python>python2 字符编码.py
涓浗
中国

 

#-*- coding:utf-8 -*-
msg = "中国"
print(msg)

#print(msg.decode())
gbk_str = msg.decode(encoding="utf-8").encode(encoding="gbk")
print(gbk_str)
print(gbk_str.decode(encoding="gbk").encode(encoding="utf-8"))

E:\Python>python2 字符编码.py
涓浗
中国
涓浗


#-*- coding:utf-8 -*-
msg = "中国"
print(msg)

#print(msg.decode())
gbk_str = msg.decode(encoding="utf-8").encode(encoding="gbk")              #python 2.x先解码再编码
print(gbk_str)
print [gbk_str,]
print(gbk_str.decode(encoding="gbk").encode(encoding="utf-8"))

print(gbk_str.decode(encoding="gbk"))
print [gbk_str.decode(encoding="gbk"),]


E:\Python>python2 字符编码.py
涓浗
中国
['\xd6\xd0\xb9\xfa']
涓浗
中国
[u'\u4e2d\u56fd']

  

在内存中使用unicode编码，显示到屏幕转换成gbk，也可以理解为命令行支持unicode，可以直接展示

 

python 3.x中发生变化

默认文件编码是utf-8，解释器编码unicode，文件加载到内存自动解码成unicode，同时把字符转换成bytes格式(bytes = 8bits),python 3.x保存时才需要转码

 

字符串变成bytes格式：

(1)b""

(2)encoding

 

字符串与bytes 

python 2 str == python 3 bytes

python 2中str就是bytes

python 3 str ==  unicode

python 3中字符串就是unicode格式

python 3 多出来的bytes格式是一个单独的数据类型

 

python 2 在windows上解码是必须的，编码成gbk格式不是必须的

python 2 在linux上,默认支持utf-8，如果是utf-8 ---->gbk，命令行乱码

如果是gbk ---->utf-8，解码是必须的，编码都不是必须的

所有的程序在内存中都是unicode

 

#python 3.x
msg = "中国"
print(msg.encode("gbk"))
print(msg)

E:\Python\mytest\python2>python 字符编码.py
b'\xd6\xd0\xb9\xfa' #转换成bytes格式，保存起来
中国 #windows默认支持unicode

E:\Python\mytest\python2>

 


E:\Python\mytest\python2>python
Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (In
tel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> bytes
<class 'bytes'>
>>> "中国".encode("gbk")
b'\xd6\xd0\xb9\xfa'
>>> "中国"
'中国'
>>> b"abc"
b'abc'
>>> type(b"abc")
<class 'bytes'>
>>>

 

3.文件操作：

• 打开文件
• 操作文件
• 关闭文件

 

3.1文件的打开模式

    打开文件的模式有：

        r，只读模式（默认）。
        w，只写模式。 (不可读；不存在则创建；存在则删除内容)
        a，追加模式。 (可读； 不存在则创建；存在则只追加内容)

 

    "+" 表示可以同时读写某个文件

        r+，可读写文件。(可读；可写；可追加)
        w+，写读
        a+，同a

 

    "U"表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）

        rU
        r+U

 

    "b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）

        rb
        wb
        ab

 

 

4.集合

 集合是一个无序的，不重复的数据组合

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系

4.1集合的定义

>>> name = {1,2,3,4,5,4,3,2}
>>> print(name)
{1, 2, 3, 4, 5}
>>> 

 

4.2集合的操作

4.2.1添加元素

>>> name = {1,2,3,4,5,4,3,2}
>>> print(name)
{1, 2, 3, 4, 5}
>>> 
>>> name.add(9)              #添加元素
>>> print(name)
{1, 2, 3, 4, 5, 9}
>>> name.add(5)              #集合中以及存在的元素，添加相当于没有添加 
>>> print(name)
{1, 2, 3, 4, 5, 9}
>>>

 

4.2.2删除元素

>>> name
{1, 2, 3, 4, 5, 9}
>>> name.remove(5)
>>> print(name)
{1, 2, 3, 4, 9}
>>> 

 

4.2.3关系运算

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

 

>>> a
{1, 10, 3, 5, 7}
>>> b
{2, 3, 4, 5, 6, 8}
>>> print(a.intersection_update(b))    #相当于a = a.intersection(b)
None
>>> a
{3, 5}
>>> b
{2, 3, 4, 5, 6, 8}
>>> 

 

 子集与超集

>>> print(a.issubset(b))          #子集
True
>>> print(a.issuperset(b))        #超集
False
>>> 

 

5.函数

5.1函数的定义

    函数是一组语句的集合,通过函数名进行调用。

#不带参数的函数
def sayhi():                #函数名
    print("Hello! I am bigroot")

sayhi()                  #调用函数

#带参数的函数
def calc(x,y):
    res = x**y
    return res        #返回函数执行结果

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

 

5.2函数特性

(1)减少重复代码

(2)便于程序扩展和维护

 

5.3函数参数与局部变量

5.3.1形参与实参

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

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

def calc(x,y):          #变量x,y为形参
    res = x**y
    return res       

a = 2
b = 3
c = calc(a,b)          #变量a,b为实参
print(c)

 

5.3.2默认参数

    定义函数时，给参数定义一个默认值，当函数调用时不给该参数赋值，则函数使用默认值执行，若给值，则按照给定值执行函数   

#默认参数此时处理参数列表的最后
def stu_register(name,age,course,country="CN"):

 

5.3.3关键参数

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

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

 

5.3.4非固定参数

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

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

    print(name,age,args)
 
stu_register("Alex",22)
#输出
#Alex 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("Alex",22)
#输出
#Alex 22 () {}#后面这个{}就是kwargs,只是因为没传值,所以为空
 
stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")
#输出
# Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}

 

5.4全局变量和局部变量

全局变量在整个程序内都有效，局部变量只在定义的函数范围内有效

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

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

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

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

name = "Alex Li"

 
def change_name(name):
    print("before change:",name)
    name = "金角大王,一个有Tesla的男人"
    print("after change", name)
 
 
change_name(name)
 
print("在外面看看name改了么?",name)
 
before change: Alex Li
after change 金角大王,一个有Tesla的男人
在外面看看name改了么? Alex Li

 

5.5返回值

要想获取函数的执行结果，就可以用return语句把结果返回

注意:

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

 

5.6嵌套函数

name = "Alex"

 
def change_name():
    name = "Alex2"
 
    def change_name2():
        name = "Alex3"
        print("第3层打印",name)
 
    change_name2() #调用内层函数
    print("第2层打印",name)
 
 
change_name()
print("最外层打印",name)
 
此时，在最外层调用change_name2()会出现什么效果？

没错， 出错了， 为什么呢？

 

5.6匿名函数

    匿名函数就是不需要显式的指定函数

def calc(n):
    return n**n
print(calc(10))
 
#换成匿名函数
calc = lambda n:n**n
print(calc(10))

 

res = map(lambda x:x**2,[1,5,7,4,8])

for i in res:
    print(i)
 
输出

1
25
49
16
64

 

5.7高阶函数

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

def add(x,y,f):

    return f(x) + f(y)
 
 
res = add(3,-6,abs)
print(res)

 

6.递归

6.1定义

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

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

calc(10)


#输出结果如下：
10
5
2
1

 

6.2递归特性:

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

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

(2)递归效率不高，递归的次数过多会导致栈溢出

 

6.3递归的应用(二分查找法)

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,23)

 

7.变量传递的不同

字符串、列表

字符串赋值给a，a在赋值给b，修改b不影响a

列表赋值给a，a在赋值给b，修改b分两种情况，修改第一层不影响a，修改第二层及以后会影响a