Python 变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问的,访问权限决定于这个变量是在哪里赋值的,变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称,两种最基本的变量作用域,第一种是局部变量,第二种是全局变量.定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域,而局部变量只能在其被声明的函数内部访问,全局变量则可以在整个程序范围内访问.

变量的作用域如下:

● L(Local)：局部作用域
● E(Enclosing)：闭包函数外的函数中
● G(Global)：全局作用域
● B(Built-in)：内建作用域

变量的属性与执行依据:

● 变量的先后顺序是：L –> E –> G –>B 的规则查找
● 在子程序中定义的变量称为局部变量
● 在程序的一开始定义的变量称为全局变量
● 全局变量作用域是整个程序,局部变量作用域是定义该变量的子程序
● 当全局变量与局部变量同名时：在定义局部变量的子程序内,局部变量起作用,在其它地方全局变量起作用
● 当内部作用域想修改外部作用域的变量时,就要用到global和nonlocal关键字了
● 局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问

全局变量: 如下定义并使用一个全局变量,来看一下效果吧.

>>> import os
>>> import sys
>>> 
>>> sum=100                      #这就是一个全局变量
>>> 
>>> def print_sum():
    print("函数中调用sum: ",sum)

>>> print_sum()                  #函数中可以读取到
函数中调用sum:  100
>>> 
>>> print("函数外调用sum: ",sum)  #外部依然可以读取到
函数外调用sum:  100

局部变量: 如下定义并使用一个局部变量,来看一下效果吧.

>>> import sys
>>> import os
>>> 
>>> def print_sum():
    sum=100
    print("函数中调用sum: ",sum)

>>> print_sum()
函数中调用sum:  100
>>> print("函数外调用sum: ",sum)
函数外调用sum:  <built-in function sum>

局部转全局: 将一个局部变量通过global关键字,转换为全局变量.

>>> import os
>>> import sys
>>> 
>>> def print_num():
    global num
    num=1000
    print("函数内调用: ",num)

>>> print_num()
函数内调用:  1000
>>> 
>>> print("函数外调用: ",num)
函数外调用:  1000

外层非全局: 如果要修改嵌套作用域(enclosing 作用域,外层非全局作用域)中的变量则需要nonlocal关键字声明一下.

>>> import sys
>>> 
>>> def outer():
    num=100
    def inner():
        nonlocal num             #声明成外层非全局作用域
        num=1000
        print("inner层：",num)
    inner()
    print("outer层：",num)

>>> outer()
inner层： 1000
outer层： 1000

## Python 函数的详解

函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段,函数能提高应用的模块性,和代码的重复利用率,一个较大的程序一般应分为若干个程序块,每一个模块用来实现一个特定的功能.所有的高级语言中都有子程序这个概念,用子程序实现模块的功能.在Python语言中,子程序的作用是由一个主函数和若干个函数构成,由主函数调用其他函数,其他函数也可以互相调用,同一个函数可以被一个或多个函数调用任意多次.

函数是python为了代码最大程度地重用和最小化代码冗余而提供的基本结构,函数是一种设计工具,它能让程序员将复杂的系统分解为可管理的部件,函数用于将相关功能打包并参数化.

在Python中可以创建如下4种函数:

● 全局函数：定义在模块
● 局部函数：嵌套于其它函数中
● lambda函数：表达式，如需多次调用
● 方法：与特定数据类型关联的函数，并且只能与数据类型关联一起使用

函数的相关定义规则:

● 函数代码块以def关键词开头,后接函数标识符名称和圆括号()
● 任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数
● 函数的第一行语句可以选择性地使用文档字符串,-用于存放函数说明
● 函数内容以冒号起始,并且必须保持缩进,否则会当作普通语句来执行
● return [表达式] 结束函数,选择性地返回一个值给调用方,也就是返回值

◆有参与无参函数◆

定义无参函数: 如下我们编写一个无参数的函数,并在后面直接调用其执行.

>>> import sys
>>> 
>>> def lyshark():                 #定义lyshark()函数,函数执行打印
...     print("hello lyshark!")
>>> 
>>> lyshark()                      #调用了lyshark()函数,打印一段话
hello lyshark!
>>> 

定义有参函数: 如下我们编写两个函数,分别给予相应的参数,其返回值则不相同.

>>> import sys
>>> 
>>> def area(width,height):       #一个计算面积的函数,其中width,height是形式参数
...     return width * height
>>> 
>>> def print_me(name):           #一个打印函数,其中name是形式参数
...     print("welcome:",name)
>>> 
>>>   
>>> print_me("lyshark")           #调用打印函数,并掺入相应的数值
welcome: lyshark
>>> 
>>> w=10
>>> h=25
>>> print(area(w,h))              #计算平方并打印,传入数值变量计算
250

◆函数的参数传递◆

默认情况下,参数通过其位置进行传递,从左至右,这意味着,必须精确地传递和函数头部参数一样多的参数,但也可以通过关键字参数、默认参数或参数容器等改变这种机制.

通常Python中所支持的参数传递形式:

● 普通参数：普通参数传递,在定义函数时就指定了规律是从左至右传递
● 默认参数：定义函数时是使用"name=value"的语法直接给变量一个值,从而传入的值可以少于参数个数
● 指定参数：调用函数时指定"name形式参数=value实际参数"的语法通过参数名进行匹配
● 动态参数：在我们定义函数时,形式参数中收集任意多基于普通参数
【定义函数时使用* ：收集普通参数,返回元组,*args】【定义函数时使用**：收集指定参数,返回列表,**kwargs】
● 动态参数解包：在调用函数时,使用**开头的参数,从而传递任意多基于普通或指定参数

什么是形式参数和实际参数:

● 形式参数：形参变量只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元.因此,形参只在函数内部有效.函数调用结束返回主调用函数后则不能再使用该形参变量
● 实际参数：实参可以是常量、变量、表达式、函数等,无论实参是何种类型的量,在进行函数调用时,它们都必须有确定的值,以便把这些值传送给形参.因此应预先用赋值,输入等办法使参数获得确定值

普通参数传递: 定义一个函数体,并且为其传递三个参数,执行函数并打印结果.

>>> def stu(name,age,country):
...     print("姓名：",name)
...     print("年龄：",age)
...     print("国籍：",country)

>>> stu("lyshark",22,"CN")
姓名： lyshark
年龄： 22
国籍： CN
>>>
>>> stu("zhangsan",33,"CN")
姓名： zhangsan
年龄： 33
国籍： CN

带默认参数传递: 同样的,我们可以给指定的字段添加默认参数,如果用户不输入则默认使用指定参数,这里需要注意的是：如果您要使用带默认参数的函数,则需要把带参数的字段,放在函数最后一项.

>>> def stu(age,country,name="none",sex="man"):
...     print("姓名: ",name)
...     print("性别: ",sex)
...     print("年龄: ",age)
...     print("国籍: ",country)
...
>>>
>>> stu(23,"CN","lyshark","man")    #此时我们给予全部的参数则无默认值
姓名:  lyshark
性别:  man
年龄:  23
国籍:  CN
>>> stu("zhangsan","mal",23,"CN")   #形参如何排列,实参就得如何排列
姓名:  23
性别:  CN
年龄:  zhangsan
国籍:  mal
>>> stu(23,"CN")                    #传递输入是忽略带有默认值的字段
姓名:  none
性别:  man
年龄:  23
国籍:  CN

动态参数传递(传递列表): 若你的函数在定义时不确定用户想传入多少个参数,就可以使用非固定参数,传递一个列表.

>>> def stu(name,age,*args):                  #*args会把多传入的参数变成一个元组.
...     print(name,age,args)
>>>
>>> stu("lyshark",22)
lyshark 22 ()                                 #这个()就是args,只是因为没传值,所以为空.
>>> 
>>> stu("lyshark",22,"a","b","c","d")         #传值后会把它当作一个列表
lyshark 22 ('a', 'b', 'c', 'd')
>>> 
>>> ls=[1,2,3,4,5]                             #先声明列表
>>> stu("lyshark",22,ls)                       #传递这个列表
lyshark 22 ([1, 2, 3, 4, 5],)                  #第三个值,打印出列表

执行函数时有·*,则把所有迭代对象拆分为单个元素作为元组的元素,如传入列表,会把列表中每一个元素遍历添加到元组中当作一个元素,如下可看到差别.

>>> def fun(*args):                          #动态参数返回元组
...     print(args,type(args))
>>>
>>> lists=[1,2,3,4]                          #定义要传递的列表
>>> fun(lists)                               #传递一个列表
([1, 2, 3, 4],) <class 'tuple'>
>>> 
>>> fun(*lists)
(1, 2, 3, 4) <class 'tuple'>

动态参数传递(传递字典): 我们可以使用**kwargs默认参数,来接收一个字典,并通过函数体打印出来.

>>> def stu(name,age,*args,**kwargs):
...     print(name,age,args,kwargs)
>>> 
>>> stu("lyshark",22)                                     #传递默认参数
lyshark 22 () {}
>>> 
>>> stu("lyshark",22,"a","b",sex="Male",province="山东")  #传递元组和字典
lyshark 22 ('a', 'b') {'sex': 'Male', 'province': '山东'}

如上方法是在调用函数的时候传递的字典,当然我们也可以直接将一个现有的字典传递进去.

>>> def fun(name,**kwargs):
...     print(name,kwargs)
>>>
>>> dic={"k1":"v1","k2":"v2"}
>>> 
>>> fun("lyshark",**dic)
lyshark {'k1': 'v1', 'k2': 'v2'}

动态参数传递(万能参数): 我们使用*与**通常情况下可以传递任何值,所以称作万能参数.

>>> def fun(*args,**kwargs):
...     print(args,type(args))
...     print(kwargs,type(kwargs))
>>>
>>> lists=[1,2,3,4,5,6,7,8,9]
>>> dic={"a":1001,"b":1002,"c":1003}
>>> 
>>> fun(*lists,**dic)
(1, 2, 3, 4, 5, 6, 7, 8, 9) <class 'tuple'>
{'a': 1001, 'b': 1002, 'c': 1003} <class 'dict'>

拓展补充(1): 其实在python中我们经常看到万能参数,比如str.format()方法,就是一个典型的万能参数的例子,如下演示,了解即可.

>>> string="hello {0},age {1}"
>>> print(string.format("lyshark",22))
hello lyshark,age 22
>>> 
>>> string="hello {name},age {age}"
>>> print(string.format(name="lyshark",age=22))
hello lyshark,age 22
>>> 
>>> string="hello {0},age {1}"
>>> print(string.format(*["lyshark",22]))
hello lyshark,age 22
>>> 
>>> dic ={"name":"lyshark","age":22}
>>> string="hello {name},age {age}"
>>> 
>>> print(string.format(**dic))
hello lyshark,age 22

拓展补充(2): 在多个同名函数的情况下,默认使用最后后一个函数,最后一个函数名会指向新的内存对象,函数名是函数体在内存中的引用.

>>> def fun(a,b):
...     return a+b
>>> def fun(a,b):
...     return a*b
>>> 
>>> print(fun(3,3))
9

拓展补充(3): 函数传递的是指针,所以我们的数据会被保留下来如下例子.

>>> def fun(x):
...     x.append(8888)
>>> 
>>> lists=[1,2,3]
>>> fun(lists)
>>> 
>>> print(lists)
[1, 2, 3, 8888]

拓展补充(4): 如下例子由于函数没有定义返回值,所以默认为none.

>>> def fun(x):
...     x.append(8888)
>>>
>>> lists=[1,2,3]
>>> lists=fun(lists)
>>> 
>>> print(lists)
None

◆通用函数返回值◆

return语句用来实现退出函数,选择性地向调用方返回一个表达式,不带参数值的return语句返回None,之前的例子都没有示范如何返回数值,如下先来看一下返回语句的规则:

● Return 语句用于退出函数,选择性地向调用方返回一个表达式
● 如果Return语句不带任何参数,则不带参数值的Return语句默认返回None
● 函数在执行过程中只要遇到Return,就会停止执行并返回结果,通俗的将遇到ret说明函数结束

默认函数返回: 如下使用默认函数返回,通常情况下返回一个确定数值.

>>> def add(num1,num2):
...     sum=num1+num2
...     print("函数内返回：",sum)
...     sum=sum+100
...     return sum
>>>
>>> temp=add(10,20)
函数内返回： 30
>>> print("函数外返回：",temp)
函数外返回： 130

选择性返回: 在函数体内部使用判断结构,如果输入的是偶数返回0,否则返回-1.

>>> def check(num):
...     if (num %2 ==0):
...     	return 0
...     else:
...     	return -1
>>>
>>> print(check(2))
0
>>> print(check(3))
-1

返回一个列表: 通过函数体的运算后,将一个列表返回给外部来接收使用.

import os

def temp_max(*args):
    all_max=[]
    temp=args
    for x in range(len(*args)):
        if temp[0][x] >= 50:
            all_max.append(temp[0][x])
    return all_max

a=[11,56,87,99,86,34,56,22,77,53]
my_max=[]

my_max=temp_max(a)
print(my_max)

◆通用函数的闭包◆

函数是一段可执行代码,编译后就固化了,每个函数在内存中只有一份实例,得到函数的入口点便可以执行函数了,一个函数可作为另一个函数的参数或返回值,可以赋给一个变量.函数可以嵌套定义,即在一个函数内部可以定义另一个函数,有了嵌套函数这种结构,便会产生闭包问题.

闭包是由函数及其相关的引用环境组合而成的实体(闭包=函数+引用环境)这个从字面上很难理解,Python中的闭包从表现形式上定义(解释)为：如果在一个内部函数里,对在外部作用域(但不是在全局作用域)的变量进行引用,那么内部函数就被认为是闭包(closure).这个定义是相对直白的,好理解的,下面举一个简单的例子来说明.

>>> def adds(x):
...     def adder(y):return x+y
...     return adder
...
>>> c=adds(10)
>>> type(c)
<class 'function'>
>>> c.__name__
'adder'
>>> c(10)
20

如上代码,在一个内部函数里：adder(y)就是这个内部函数,对在外部作用域(但不是在全局作用域)的变量进行引用：x就是被引用的变量,x在外部作用域adds里面,但不在全局作用域里,则这个内部函数adder就是一个闭包.闭包=函数块+定义函数时的环境,adder就是函数块,x就是环境,当然这个环境可以有很多,不止一个简单的x.

闭包返回函数: 通过使用闭包,返回一个函数,并使用函数做进一步的计算.

import os

def post_sum(*args):
    def sum():
        x=0
        for y in args:
            x=x+y
        return x
    return sum


post_sum(1,2,3,4,5)    #post_sum并没执行,而是返回一个指向求和的函数的函数名sum的内存指针

fp=post_sum(1,2,3,4,5) 
print(type(fp))        #调用f()函数,才真正调用了sum函数进行求和,这其实就是闭包

print(fp())

闭包选择返回: 通过返回值判断,来使用不同的闭包函数,从而返回不同的结果.

import os

def post(temp,*args):
    def sum():
        x=0
        for y in args:
            x=x+y
        return x
    def div():
        x=1
        for y in args:
            x=x*y
        return x

    if temp=="1":
        return sum
    else:
        return div

fp=post("1",1,2,3,4)     #使用加法闭包函数
print(type(fp))
print(fp())

fp1=post("0",1,2,3,4)    #使用乘法闭包函数
print(type(fp1))
print(fp1())

闭包返回函数列表: 通过使用闭包函数,一次性返回多个函数列表,每个函数拥有独立空间.

>>> def count():
    fs=[]
    for i in range(1,4):
        def f():
            return i*i
        fs.append(f)
    return fs

>>> f1,f2,f3=count()
>>> print(f1())
9
>>> print(f2())
9
>>> print(f3())
9

◆函数嵌套与递归◆

除了函数的闭包以外,函数还支持两种调用方式,一种是嵌套函数,另一种是递归函数,这里需要注意的是,最好在开发中尽量少用这样的结构,这种结构一旦层数变多将很难后期进行维护,所以你懂的.

嵌套函数：即指在一个函数体中,嵌套另外一个函数体,内部函数执行后将结果返回给外部函数使用
递归函数：函数在其内部调用它自己,就叫做递归,但递归需设置退出条件,不然会一直递归下去,变成一个死循环

嵌套函数: 定义一个嵌套函数,并打印出其执行轨迹,并理解其原理.

import os

name="lyshark"

def chage_name():
    name="lyshark blog"

    def chage_name_new():
        name="mkdirs blog"
        print("第3层循环打印: ",name)

    chage_name_new()              #在函数内部调用内部的函数
    print("第2层循环打印: ",name)  #第二层函数执行结果

chage_name()                      #调用最外层函数
print("查看最外层变量: ",name)     #查看外层变量

>>>
第3层循环打印:  mkdirs blog
第2层循环打印:  lyshark blog
查看最外层变量:  lyshark

递归函数(1): 使用递归的方式实现指定数字的阶乘,如下所示.

import os

def fun(n):
    if 0==n:              # n=0 的话直接返回空,对用户输入的零进行判断
        return None
    elif 1==n:            # n=1 的话就不再递归
        return n
    else:
        return n*fun(n-1) # 递归在执行f(n-1),直到f(1)

print(fun(5))             # 120
'''
    f(5)的执行过程如下
        ===> f(5)
        ===> 5 * f(4)
        ===> 5 * (4 * f(3))
        ===> 5 * (4 * (3 * f(2)))
        ===> 5 * (4 * (3 * (2 * f(1))))
        ===> 5 * (4 * (3 * (2 * 1)))
        ===> 5 * (4 * (3 * 2))
        ===> 5 * (4 * 6)
        ===> 5 * 24
        ===> 120
'''

递归函数(2): 如下实例传入一个数据,每次递归增加1,直到满足x>=5则结束递归.

>>> def fun(x):
...     x+=1
...     if x >= 5:
...        return 0
...     return fun(x)
>>>
>>> r=fun(5)
>>> print(r)
0

递归函数(3): 如下实例,传入一个数据,每次在数据本身除以2直到除数为1则停止.

>>> def fun(x):
...     print("--->%d"%x)
...     if int(x/2)==0:
...         return x
...     return fun(int(x/2))
>>>
>>> fun(10)
--->10
--->5
--->2
--->1

小总结: 使用递归实现二分法,也就是折半查找法.

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

◆lambda 匿名函数◆

python 使用lambda来创建匿名函数,所谓匿名即不再使用 def 语句这样标准的形式定义一个函数.

匿名函数的几个注意事项:

● lambda只是一个表达式,函数体比 def 简单很多
● lambda表达式会自动return返回值,条件为真返回True,条件为假返回False
● lambda函数拥有自己的命名空间,且不能访问自己参数列表之外或全局命名空间里的参数
● lambda的主体是一个表达式,而不是一个代码块,仅仅能在lambda表达式中封装有限的逻辑进去
● lambda函数看起来只能写一行,却不等同于C或C++的内联函数,应该区别对待,毕竟是两们不同语言.

定义匿名函数(1): 使用功能最基本的语法定义一个匿名函数.

>>> sum=lambda x,y,z: x+y+z
>>> 
>>> print("三个数相加：",sum(10,20,30))
三个数相加： 60

定义匿名函数: 对于简单的函数,也存在一种简便的表示方式,即：lambda表达式.

# ###################### 普通函数 ######################
# 定义函数（普通方式）
def func(arg):
    return arg + 1
    
# 执行函数
result = func(123)
    
# ###################### lambda ######################
    
# 定义函数（lambda表达式）
my_lambda = lambda arg : arg + 1
    
# 执行函数
result = my_lambda(123)

向匿名函数传递列表: 想一个匿名函数传递一个列表,并分别计算后返回相应数据.

>>> res=map(lambda x:x**2,[1,5,4,8])
>>> 
>>> for i in res:
    print(i)

1
25
16
64

◆函数编写实例(拓展)◆

拓展(1): 编写函数,计算传入字符串中数字、字母、空格、其他的个数,并统计出来.　

def fun(s):
    digitnum, alphanum, sapcenum, othernum=0,0,0,0
    for i in s:
        if i.isdigit():
            digitnum+=1
        elif i.isalpha():
            alphanum+=1
        elif i.isspace():
            sapcenum+=1
        else:
            othernum+=1
    return (digitnum,alphanum,sapcenum,othernum)

拓展(2): 编写函数,判断用户传入的对象(字符串、列表、元组)的长度是否大于5,并输入相关状态.

def fun(s):
    ret=False
    if isinstance(s,str) or isinstance(s,list) or isinstance(s,tuple):
       if len(s)>5:
           ret=True
    return ret

拓展(3): 编写函数,检查用户传入的对象(字符串、列表、元组)的每一个元素是否含有空内容.

def fun(s):
    ret=False
    if isinstance(s, str) or isinstance(s, list) or isinstance(s, tuple):
        for i in s:
           if i=='':
               ret=True
               break
    return ret

拓展(4): 编写函数,检查获取传入列表或元组对象的所有奇数位索引对应的元素,并将其作为新列表返回给调用者.

def fun(s):
    if isinstance(s,list) or isinstance(s,tuple):
        l=[]
        for i in range(1,len(s),2):
            l.append(s[i])
        return l
    return None

拓展(5): 编写函数,检查传入字典的每一个value的长度,如果大于2,那么仅保留前两个长度的内容,并将新内容返回给调用者.

def fun(s):
    if isinstance(s,dict):
        for i in s:
            if len(s[i])>2:
                s[i]=s[i][0:2]
    return s

## Python 内置函数

help(): 详细查看某个类有那些方法或者方法的具体使用.

>>> help(str)
>>> help(str.strip)

dir(): 查看指定类型,支持的方法或具体使用.

>>> dir(os)
>>> dir(str.strip)

int(): 实例化数字类型,或将其他类型转换为数字类型,或各种进制转换为十进制.

>>> temp = int(21)           #实例化数字类型
>>> print(type(temp),temp)   #打印类型,和参数值
<class 'int'> 21

>>> print(int("110101",base=2))   #将二进制转为十进制
53
>>> print(int("156",base=8))      #将八进制转为十进制
110
>>> print(int("1A2C31",base=16))  #将十六进制转为十进制
1715249

float(): 实例化浮点类型,或将数字字符串转换为浮点型,仅限于数字字符串.

(1) 实例化浮点类型
>>> f = float(12)
>>> print(type(f),f)
<class 'float'> 12.0

(2) 将数字字符串转换为浮点类型
>>> s = "12"
>>> type(s)
<class 'str'>
>>> i = float(s)
>>> print(type(i),i)
<class 'float'> 12.0

str(): 实例化字符串类型,或将其他类型转换为字符串类型.

(1) 实例化字符串类型
>>> string = "python"
>>> print(type(string))
<class 'str'>

(2) 将其他类型转换为字符串类型了
>>> string = 88888
>>> type(string)
<class 'int'>
>>> i = str(string)
>>> print(type(i),i)
<class 'str'> 88888

>>> l = [1,2,3,4,5]
>>> a = str(l)
>>> print(type(a),a)
<class 'str'> [1, 2, 3, 4, 5]
#注意：列表格式或字典格式的字符串类型转换为列表或者字典需要使用json模块

list(): 将其他类型转为列表类型.

(1) 实例化列表类型
>>> l = list(["redhat","centos","ubuntu"])
>>> print(type(l),l)
<class 'list'> ['redhat', 'centos', 'ubuntu']

(2) 将其他类型转换为列表
>>> s = "python"
>>> l = list(s)
>>> print(type(l),l)
<class 'list'> ['p', 'y', 't', 'h', 'o', 'n']

>>> t = ("python","I","like")
>>> l1 = list(t)
>>> print(type(l1),l1)
<class 'list'> ['python', 'I', 'like']

tuple(): 实例化元组类型,或将其他类型转换为元组类型.

(1) 实例化元组类型
>>> t1 = tuple(("redhat","centos","ubuntu","opensuse"))
>>> print(type(t1),t1)
<class 'tuple'> ('redhat', 'centos', 'ubuntu', 'opensuse')

(2) 将其他类型转换为元组类型
>>> l = [11,22,33,44,55]
>>> type(l)
<class 'list'>
>>> t = tuple(l)
>>> print(type(t),t)
<class 'tuple'> (11, 22, 33, 44, 55)

dict(): 实例化字典,或将元组列表转换为字典类型仅限元组形式列表类型.

(1) 实例化字典类型
>>> d1 = dict({"os":"ubuntu","version":15.10,"kernel":"4.2.0-16"})
>>> print(type(d1),d1)
<class 'dict'> {'version': 15.1, 'os': 'ubuntu', 'kernel': '4.2.0-16'}

(2) 将元组形式的列表转换为字典
>>> l1 = [('a',1),('b',11),('c',45)]
>>> d1 = dict(l1)
>>> print(type(d1),d1)
<class 'dict'> {'b': 11, 'c': 45, 'a': 1}

#注意：zip()这个内置方法可以将两个列表生成元组形式列表类型

set(): 实例化可变集合类型,或其他类型转换成集合类型.

(1) 实例化集合类型
>>> s = set({"fedora","geentoo","debian","centos"})
>>> print(type(s),s)
<class 'set'> {'fedora', 'centos', 'debian', 'geentoo'}

(2) 将其他类型转换成集合set类型
>>> l = ["centos","centos","redhat","ubuntu","suse","ubuntu"]
>>> s = set(l)
>>> print(type(s),s)
<class 'set'> {'ubuntu', 'centos', 'redhat', 'suse'}

>>> d = {"kernel":"Linux","os":"ubuntu","version":"15.10"}
>>> s = set(d.keys())
>>> print(type(s),s)
<class 'set'> {'kernel', 'version', 'os'}

frozenset(): 实例化不可变集合,或类型转换成不可变集合类型.

(1) 实例化不可变集合
>>> fs = frozenset({"redhat","centos","fedora","debian","ubuntu"})
>>> print(type(fs),fs)
<class 'frozenset'> frozenset({'fedora', 'ubuntu', 'centos', 'debian', 'redhat'})

(2) 类型转换成不可变集合
>>> l = [1,2,3,4,4,5,5]
>>> fs1 = frozenset(l)
>>> print(type(fs1),fs1)
<class 'frozenset'> frozenset({1, 2, 3, 4, 5})

bool(): 0,"",None,[],(),{}都为假,其余都为真,是int的子类.

>>> bool(0)
False
>>> bool("abc")
True
>>> bool("")
False
>>> bool([])
False
>>> bool()
False
>>> issubclass(bool,int)
True

bytes(): 将字符串类型转换成字节byte类型,在计算机底层都是以二进制存储数据的.

(1) 将字符串转换为字节类型
>>> s = "大神"
>>> p = bytes(s,encoding="utf-8")
>>> print(type(p),p)
<class 'bytes'> b'\xe8\x9f\x92\xe8\x9b\x87'

(2) 将字节类型重新转换为字符串
>>> new_s = str(p,encoding="utf-8")
>>> print(type(new_s),new_s)
<class 'str'> 大神

bytearray(): 和bytes()是一样的,只是返回一个byte列表,且序列中的元素的取值范围为 [0,255].

>>> a = bytearray("大神",encoding="utf-8")
>>> print(type(a),a)
<class 'bytearray'> bytearray(b'\xe8\x9f\x92\xe8\x9b\x87')
>>> a[0]
232
>>> a[1]
159
>>> a[2]
146
>>> a[4]
155
>>> a[5]
135

open(): 打开一个文件对象,用于对文件的操作处理.

>>> with open("/etc/passwd","r") as f:
... for line in f:
...     print(line)

type(): 查看某个实例属于哪个类型.

>>> s = "python"
>>> l = [1,2,3,4]
>>> t = ("linux","python")
>>> d = {"name":"linux","age":12}
>>> print(type(s),type(l),type(t),type(d))
<class 'str'> <class 'list'> <class 'tuple'> <class 'dict'>

len(): 查看实例中的长度,说白点就是元素个数,以为单位字符计算.

>>> s = "python"
>>> len(s)
6

>>> s = "大神"
>>> len(s)
2

>>> b = bytes(s,encoding="utf-8") #以字节为单位计算
>>> len(b)
6

input(): 默认输入的格式为字符串,输入的数字也是字符串,需要int()转换.

>>> data = input("please say something:")
please say something:today is good day
>>> print(data)
today is good day

>>> data1 = input("please say something:")
please say something:123
>>> print(type(data1),data1)
<class 'str'> 123

# print() 输出,格式化输出
>>> name = "python"
>>> print("I love %s" % name)
I love python

all(): 接收一个迭代对象,当对象中的元素全部为真的时候,才会返回真.

>>> s = ["python","php","java"]
>>> print(all(s))
True
>>> a = ["","python","php"]
>>> print(all(a))
False

any(): 只要有一个为真则为真,全为假则为假.

>>> a = ["","python","php"]
>>> print(any(a))
True
>>> s = ["",0,(),[],{},None]
>>> print(any(s))

max(),min(),sum(): 计算数字系列中的最大,最小,求和.

>>> r = max([11,22,33])
>>> print(r)
33

>>> r1 = min([11,22,33])
>>> print(r1)
11

>>> r2 = sum([11,22,33])
>>> print(r2)
65

abs(): 求一个数的绝对值.

>>> print(abs(-123123))
123123
>>> print(abs(12345))
12345

power(): 求几次方和**是一样的.

>>> print(pow(2,10))
1024
>>> 2**10
1024

round(): 四舍五入,计算函数.

>>> print(round(18.8))
19
>>> print(round(18.4))
18

divmod(): 除法得余数,在分页功能中会用到.

>>> print(divmod(78,10))
(7, 8)
>>> print(divmod(45,10))
(4, 5)

chr(),ord(): ascii表的对应关系,十进制转字符,字符转数字.

>>> r = chr(65)
>>> print(r)
A
>>> chr(65),chr(122)
('A', 'z')

>>> n = ord("a")
>>> print(n)
97

bin(),oct(),hex(): 几个常用的进制转换.

>>> bin(10)    #十进制转二进制
'0b1010'
>>> oct(9)     #十进制转八进制
'0o11'
>>> hex(15)    #十进制转十六进制
'0xf'

enumerate(): 枚举类型,实现循环的时候打印出行号,默认是0开始,也可以设置1开始.

>>> li = ["redhat","centos",'fedodra']
>>> for index,data in enumerate(li):
... print(index,data)
... 
0 redhat
1 centos
2 fedodra

>>> li = ["redhat","centos",'fedodra']
>>> for index,data in enumerate(li,1):
... print(index,data)
... 
1 redhat
2 centos
3 fedodra

sorted(): 排序,不能数字和字母在一起排序和list.sorted()是一样的.

>>> l1 = [1,5,2,55,33]
>>> a = sorted(l1)
>>> print(a)
[1, 2, 5, 33, 55]

>>> l2 = [1,5,2,55,33,66]
>>> l2.sort()
>>> print(l2)
[1, 2, 5, 33, 55, 66]

reversed(): 逆序和list.reverse()是一样的.

>>> l3 = [33,22,55,11]
>>> a = reversed(l3)
>>> print(list(a))

>>> l4 = [33,22,55,11,44]
>>> l4.reverse()
>>> print(l4)
[44, 11, 55, 22, 33]

slice(): 和字符串列表的切片的功能是一样的.

>>> s = "python"
>>> s[0:4]
'pyth'
>>> s[0:4:2]
'pt'

>>> b = slice(0,4,2)
>>> print(b)
slice(0, 4, 2)
>>> s[b]
'pt'

zip(): 取一个或多个序列为参数,把序列中的并排元素配成元组,返回元组形式的列表类型,当元素长度不同时以最短序列的长度为准.

>>> l1 = ['烧饼',11,22,33]
>>> l2 = ['is',11,22,33]
>>> l3 = ['sb',11,22,33]
>>> r = zip(l1,l2,l3)
>>> print(list(r))
[('烧饼', 'is', 'sb'), (11, 11, 11), (22, 22, 22), (33, 33, 33)]

>>> temp = list(r)[0]
>>> ret = ' '.join(temp)
>>> print(ret)
烧饼 is sb

# 两个列表合成一个字典
>>> keys = [1,2,3,4,5,6,7]
>>> vaules = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat']
>>> D = {}
>>> for (k,v) in zip(keys,values):
... D[k] = v
... 
>>> D
{1: 'Sun', 2: 'Mon', 3: 'Tue', 4: 'Wed', 5: 'Thu', 6: 'Fri', 7: 'Sat'}

complex(): 复数之间的运算准则.

>>> complex(1, 2)
(1 + 2j)
>>> complex(1) #数字
(1 + 0j)
>>> complex("1") #当做字符串处理
(1 + 0j)
>>> complex("1+2j")
(1 + 2j)
#注意：这个地方在“+”号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错

globals(),locals(): 显示全局变量和本地变量.

>>> NAME = 'tomcat'
>>> def show():
... a = 123
... b = 456
... print(locals())
... print(globals())
... 
>>> show()

range(): 生成遍历循环数据.

>>> for i in range(4): 
... print(i)
... 
0
1
2
3

>>> for i in range(1,4,2): 
... print(i)
... 
1
3

format(): 格式化输出的,和百分号是同样的功能.

>>> print("1 am {},age {}".format('jason',18)) # 用{}当作占位符
>>> print("1 am {},age {}".format(*['jason',18])) # 用*传递一个列表进去
>>> print("1 am {0},age {1}，score{1}".format('jason',18)) # 1 am jason,age 18，score18 用 0，1等数字来应用

hash(): 一般用在字典中的Key是进行hash计算后,值存入内存,hash值.

>>> dic = {'name':'SB'}
>>> print(hash(dic['name']))

filter(): filter(函数,可迭代对象),fileter内部,循环第二个参数,将每一个元素执行第一个函数.

>>> def f2(a):
... if a>22:
... return True

>>> li = [11,22,33,44,55]
>>> ret = filter(f2,li)
>>> print(list(ret))

#注意: 对于简单的函数用lambda可以实现
>>> result = filter(lambda a: a > 33,li)
>>> print(list(result))

map(): map(函数,可迭代的对象),循环第二个参数,将每一个元素执行第一个函数,就把返回值存入结果result中.

>>> l1 = [11,22,33,44,55,66]
>>> def f3(a):
... return a + 100

>>> result = map(f3,l1)
>>> print(list(result))

#注意: 对于简单的函数用lambda可以实现
>>> result = map(lambda a: a + 100,l1)
>>> print(list(result))

iter(): 用于生成迭代器,for循环就是调用iter()生成迭代对象.
next(): 用于遍历迭代器,for循环就是调用next()实现,不过当使用next()遍历时,迭代器没有元素时会报错,for则不会.

>>> a = iter([1,2,3,4,5])
>>> a
<list_iterator object at 0x101402630>
>>> a.__next__()
1
>>> a.__next__()
2
>>> a.__next__()
3
>>> a.__next__()
4
>>> a.__next__()
5
>>> a.__next__()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration