标签：不定长参数   了解   执行   传递   python3   传参   one   作用   对象   

一、        Python概述

1、python是一门面向对象，解释型的脚本语言。语法简洁，编写效率高，但是执行（底层运行）效率低(总的来说解释语言执行效率低于编译语言)。

注意：本博客所有的代码都是按照Python3的标准创建的。

2、主要的语言特点是：任何的语句可以独立存在。并且代码块是以（:）开始的，注意每个语句的缩进空格（缩进格式决定语句的包含关系和执行顺序），在python里面缩进空格相当于java里面的“{ }”，并且没有一个明确的规定说要求几个空格，一般如果本句被上一句包含或者是上个语句的子句时，本句的会距上句缩进4个空格或者一个tab键（格式如下）

以下代码将会执行错误：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名：test.py

 if True:
    print "Answer"
    print "True"
else:
    print "Answer"
    # 没有严格缩进，在执行时会报错
  print "False"

执行以上代码，会出现如下错误提醒：

$ python test.py  
  File "test.py", line 5
    if True:
    ^
IndentationError: unexpected indent

在 Python 的代码块中必须使用相同数目的行首缩进空格数。

3、python的基础语法与java，shell脚本都有很多相似之处，可以参照这两种语言进行学习。

二、python文件的注释，声明，

1.python文件的首句声明和shell文件的声明相似，"#!"解释器路径

#!/usr/bin/python

2.注释

2.1单行注释，以”#“开头，注意：在python里引号也是成对存在的

# 单行注释、python3的输出语句，字符串单引号括起来 
print(‘hello python!‘)
# 单行注释、python3的输出语句，字符串双引号括起来 
print("hello python！")

2.2多行注释，用三个单引号(‘‘‘  ‘‘‘)或者双引号（"""  """）括起来，注意：引号要成对存在

"""
python里面 类的构造方法能不能用关键字传参,
在python里面不能有++，--，但是在java中可以，shell里面用let var_name ++
这是以回车结尾
"""
print(‘人生苦短，好好学习python！‘, end=‘\n‘)
‘‘‘
这是python3的输出函数的基本用法
 print(self, *args, sep=‘ ‘, end=‘\n‘, file=None)
 可以改变里面的任意参数，end表示输出后以什么结尾
 *args：表示不定长参数，后面会详细介绍
 

‘‘‘
print(‘人生苦短，好好学习python！‘, end=‘^_^‘)
print(‘人生苦短，好好学习python！‘, end=‘^_^‘)

输出结果：

人生苦短，好好学习python！
人生苦短，好好学习python！^_^人生苦短，好好学习python！^_^

注意：在书写字符串时会受到一些特殊字符（‘," 等）的影响，用三个单引号或者双引号不失为一个好的解决方法。同时换行输出也是。

下面会报错：

print(‘let‘t go‘)

下面会正常输出：

print(‘‘‘let‘s go!‘‘‘)

下面会报错：

print(‘---------------‘)
print(‘
      春眠不觉晓
        处处蚊子咬
            梦来春雨声
            夜里明月笑        
‘)

下面是换行输出：

#输出时空格换行等都不会忽略，就连空行和空格都
print(‘---------------‘)
print(‘‘‘
      春眠不觉晓
        处处蚊子咬
            梦来春雨声
            夜里明月笑        

‘‘‘)
print(‘---------------‘)

结果如下：
---------------

      春眠不觉晓
        处处蚊子咬
            梦来春雨声
            夜里明月笑        

---------------

Process finished with exit code 0

3.空格

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住：空行也是程序代码的一部分。

三、变量

3.1变量的声明

python的变量定义和shell命名一样，都可以直接定义

3.1.1对单个变量赋值

variable_name = value

3.1.2对多个变量赋予同一个值

variable_name1=variable_name2=variable_name3……=value

3.1.2对多个变量赋予不一样的值

variable_name1,variable_name2,variable_name3……=value1,value2,value3……

3.2变量名的命名规则

1、字母，数字，下划线组成

2、数字不能开头

3、严格区分字母大小写

4、不能直接用保留字或者关键字（都是小写的）

3.3变量的作用域

3.3.1 变量作用域（scope）在Python中是一个容易掉坑的地方。
Python的作用域一共有4中，分别是：

L （Local） 局部作用域：定义在函数中的变量
E （Enclosing） 闭包函数外的函数中
G （Global） 全局作用域
B （Built-in） 内建作用域
以 L --> E --> G -->B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。

#全局变量
global_variable = 123
def function_name ():
    glc = 345 #局部变量
    print(‘函数中调用全局变量：‘,global_variable)
    return glc
print(‘全局变量：‘,global_variable)
# print(glc)局部变量不能在本函数外被调用
print(function_name())#局部变量只能在本函数中调用

结果如下：

全局变量： 123
函数中调用全局变量： 123
345

3.3.2 闭包Closure
闭包的定义：如果在一个内部函数里，对在外部函数内（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包(closure)。

这个概念在javascript里面具有很好的体现。

函数嵌套/闭包中的作用域：

def external():
    global a #声明一个全局变量
    a = 200
    print (‘本地函数调用：‘,a)

    b = 100#创建外部函数变量
    #定义内部函数
    def internal():
        # nonlocal b
        print (‘调用外部函数的变量：‘,b)
        b = 200#给外部函数的变量修改值
        return b

    internal()#执行内部函数
    print (‘输出外部函数变量的值：‘,b)

print (‘外部函数的结果：‘,external())

运行结果：

UnboundLocalError: local variable ‘b‘ referenced before assignment

会报错- 引用在赋值之前，Python3有个关键字nonlocal可以解决这个问题，但在Python2中还是不要尝试修改闭包中的变量。

关于闭包中还有一个坑：

from functools import wraps#导入模块（导包）

def wrapper(log):
    def external(F):
        @wraps(F)
        def internal(**kw):
            if False:
                log = ‘modified‘
            print( log)
        return internal
    return external

@wrapper(‘first‘)
def abc():
    pass

print (abc())

也会出现 引用在赋值之前 的错误，原因是解释器探测到了 if False 中的重新赋值，所以不会去闭包的外部函数（Enclosing）中找变量，但 if Flase 不成立没有执行，所以便会出现此错误。除非你还需要else: log=‘var‘ 或者 if True 但这样添加逻辑语句就没了意义，所以尽量不要修改闭包中的变量。

好像用常规的方法无法让闭包实现计数器的功能，因为在内部进行 count +=1 便会出现 引用在赋值之前 的错误，解决办法：（或Py3环境下的 nonlocal 关键字）

def counter(start):
    count =[start]
    def internal():
        count[0] += 1
        return count[0]
    return internal

count = counter(0)
for n in range(10):
    print (count())
# 1,2,3,4,5,6,7,8,9,10

count = counter(0)
print (count())

3.3.3

locals() 和 globals()
globals()
global 和 globals() 是不同的，global 是关键字用来声明一个局部变量为全局变量。globals() 和 locals() 提供了基于字典的访问全局和局部变量的方式

比如：如果函数1内需要定义一个局部变量，名字另一个函数2相同，但又要在函数1内引用这个函数2。

def var():
    pass



def f2():

    var = ‘Just a String‘

    f1 = globals()[‘var‘]

    print (var)

    return (type(f1))



print (f2())

# Just a String

# <type ‘function‘>

locals()
如果你使用过Python的Web框架，那么你一定经历过需要把一个视图函数内很多的局部变量传递给模板引擎，然后作用在HTML上。虽然你可以有一些更聪明的做法，还你是仍想一次传递很多变量。先不用了解这些语法是怎么来的，用做什么，只需要大致了解locals()是什么。
可以看到，locals()把局部变量都给打包一起扔去了。

@app.route(‘/‘)

def view():

    user = User.query.all()

    article = Article.query.all()

    ip = request.environ.get(‘HTTP_X_REAL_IP‘,request.remote_addr)

    s = ‘Just a String‘

    return render_template(‘index.html‘, user=user,article = article, ip=ip, s=s)

#或者 return render_template(‘index.html‘, **locals())

一、 Python概述、变量

标签：不定长参数   了解   执行   传递   python3   传参   one   作用   对象   

原文地址：http://www.cnblogs.com/ljw-cnqh/p/7004458.html