day3

1. 函数基本语法及特性

2. 参数与局部变量

3. 返回值

嵌套函数

4.递归

5.匿名函数

6.高阶函数

7.内置函数

集合

a = {1,2,3,4}
b = {3,4,5,6}
print(a.symmetric_difference(b))#去掉相同的数据，保留不同的数据
print(a.difference(b))#a有，b没有
print(a.union(b))#a并b
print(a.intersection(b))#a交b

字典

key-value对

1. 特性：
2. 无顺序
3. 去重
4. 查询速度快，比列表快多了
5. 比list占用内存多

hash类型，查询速度很快

先说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'xe4xbdxa0xe5xa5xbd' bytes类型－－>按照指定编码转成你能看懂的文字

编码应用比较多的场景应该是爬虫了，互联网上很多网站用的编码格式很杂，虽然整体趋向都变成utf-8，但现在还是很杂，所以爬网页时就需要你进行各种编码的转换，不过生活正在变美好，期待一个不需要转码的世界。

最后，编码is a piece of fucking shit, noboby likes it.

函数是什么?

函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，具体区别，我们后面会讲，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。

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

特性:

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

def sayhi():#函数名

    print("Hello, I'm nobody!")

 

sayhi() #调用函数

 

带参数

def sayhi(a,b):
    print('hello %s %s'%(a,b))

sayhi('ronghui','jiangyijing')

2.函数参数与局部变量　　

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

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

默认参数

def stu(age,name,city='sh'):
    print('%s %s %s' %(name,age,city))

stu(25,'rh')

关键参数

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

stu(age=22,name='rh',city="python",)

非固定参数

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

    print(name,age,args)

 

stu("Alex",22)

#输出

#Alex 22 () #后面这个()就是args,只是因为没传值,所以为空

 

stu("Jack",32,"CN","Python")

#输出

# Jack 32 ('CN', 'Python')

 

 

 

还可以有一个**kwargs

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

    print(name,age,args,kwargs)

 

stu("Alex",22)

#输出

#Alex 22 () {}#后面这个{}就是kwargs,只是因为没传值,所以为空

 

stu("Jack",32,"CN","Python",sex="Male",province="ShanDong")

#输出

# Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}

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

全局与局部变量

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

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

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

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

 

3.返回值　

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

注意:

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

嵌套函数　

list_qiantao = [1,13,25,21,41,16,28,999,321]
print(list_qiantao)
def test(x):
    for i in range(len(x)):
        temp=0
        for i in range(len(x)-1):
            if x[i]>x[i+1]:#当前一个比后一个大时，互换位置
                temp=x[i]
                x[i]=x[i+1]
                x[i+1]=temp

        print(i,'---',x)

test(list_qiantao)

递归

递归特性:

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

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

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

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

list_qiantao = [1,13,25,21,41,16,28,999,321,2]
def two_half(datalist,num):

    datalist=sorted(datalist)
    print(datalist)
    if len(datalist) > 1:
        mid = int(len(datalist)/2)
        if datalist[mid] == num:
            print('find it')
            print(datalist[mid])
        elif datalist[mid] > num:
            print("zai zuo bian")
            print(datalist[0:mid])
            return two_half(datalist[0:mid],num)
        else:
            print("zai you bian")
            print(datalist[mid+1:])
            return two_half(datalist[mid+1:],num)
    else:
        if datalist[0] == num:
            print("find it")
        else:
            print('mei you zhe ge shu zi')

two_half(list_qiantao,25)

匿名函数

#这段代码

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)

 

高阶函数

def add(x,y,f):

    return f(x) + f(y)

 

 

res = add(3,-6,abs)

print(res)

 

8. 内置参数　　

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:rh
 user = 'rh'
 passwd = 'abc'
 def auth(auth_type):
     def out_wrapper(func):
         def wrapper(*args,**kwargs):
             if auth_type == 'local':
                 username = input('username:')
                 password = input('password:')
                 if username == user and password == passwd:
                     print('33[32;1mWelcome to your home33[0m')
                     res = func(*args,**kwargs)
                     print('after authentication!')
                     return res
                 else:
                     print('33[31;1mIvalid username or password33[0m')
             elif auth_type == 'ldap':
                 username = input('username:')
                 password = input('password:')
                 if username == user and password == passwd:
                     print('33[31;1mlao zi buhui ladp33[0m')
                 else:
                     print('invalid username or password')

         return wrapper
     return out_wrapper



 def index():
     print('in then index')

 @auth(auth_type='local')
 def home():
     print('in the home')
     return 'from home'

 @auth(auth_type='ldap')
 def bbs():
     print('in the bbs')
     return 'from bbs'

 index()
 print(home())
 bbs()

 print(all([1,-2]))#可迭代对象，如果有0返回false
 print(any([0,1,2,3]))#有一个真，就就是真
 print(type(ascii([1,2])))#str将列表变成字符串
 print(bin(4))#吧数字转成二进制
 print(bool(0))
 a = bytes('abc',encoding='utf-8')
 print(a)
 def sayhi():
     pass
 print(callable(sayhi))#是否可调用

 print(chr(98))#吧数字转成ASCII码表示成英文
 print(ord('A'))#吧英文字母转成数字
 code = 'for i in range(10):print(i)'
 exec(code)

 print(dir(sayhi))#返回方法
 print(divmod(5,3))#5/3=1余2
 x=1
 print(eval('x+1'))#执行字符串中的内容

 calc = lambda x:print(x)
 calc(5)

 c = map(lambda x:x*x,range(10))#对所有的数据处理，并返回
 print(type(c))
 for i in c:
     print(i)

 d = filter(lambda n:n>5,range(10))#过滤符合条件的值
 print(type(d))
 for i in d:
     print(i)

 res = [i*2 for i in range(10)]
 for i in res:
     print(i)
 x=2
 e = '3 if x>5 else 2'
 print(eval(e))

 import functools
 res = functools.reduce(lambda x,y:x*y,range(1,10))
 print(res)

 a = frozenset([1,2,3,4])#不可变列表 相当于元组 print(globals())#判断变量是否存在 a = globals() b = list(a) print(b) if 'res' in b:     print('ok') print(hash('a')) def test():     local_var = 333     print(locals()) test() print(globals()) print(globals().get('local_var')) print(max([1,2,3,4])) #next()=__next__() print(hex(15)) print(oct(15)) print(pow(3,3))#3的3次方 print(repr(c))#字符串 for i in reversed([1,2,3]):     print(i) print(round(1.3232,2))#保留两位小数 d=range(20) d=d[slice(2,5)] print(d) a = {6:2,8:0,1:4,-5:6,99:11,4:22}#字典 无序 print(a) print(sorted(a.items())) print(sorted(a)) print(sorted(a.items(),key=lambda x:x[0])) print(sum([1,2,3])) a=[1,2,3,4] b=['a','b','c','d'] for i in zip(a,b):     print(i) ls = [1,2,3] rs = map(str, ls) for i in rs:     print(type(i)) lt = [1, 2, 3, 4, 5, 6] def add(num):     return num + 1 rs = map(add, lt) for i in rs:     print(i)import decorator__import__('decorator')