python关于引用，装饰器，列表知识讲解

变量的引用

变量和数据都是保存在内存中的

在 python 中函数的参数传递以及返回值都是靠引用传递的

标准数据类型

在内存中存储的数据可以有多种类型。

例如，一个人的年龄可以用数字来存储，他的名字可以用字符来存储。

Python 定义了一些标准类型，用于存储各种类型的数据。

Python 有五个标准的数据类型：

Numbers（数字）

String（字符串）

List（列表）

Tuple（元组）

Dictionary（字典）

引用的概念

在 python 中

变量和数据是分开存储的

数据保存在内存中的一个位置

变量中保存的是数据在内存中的地址

变量中记录数据的地址，就叫做引用

使用 id() 函数可以查看变量中保存数据所在内存的地址

引用（引用变量时用的是内存地址）
In [1]: a = 1

In [2]: id(a)
Out[2]: 11398248

In [3]: id(1)
Out[3]: 11398248

In [4]: b = 1

In [5]: id(b)
Out[5]: 11398248

In [6]: b = 2

In [7]: id(b)
Out[7]: 11398224

# 定义了一个函数，准备了一个叫num的变量，引用的是数字10的内存地址
def test(num):
    print '在函数内部 %d 对应的内存地址是 %d' % (num,id(num))
# 定义了一个数字变量
a=10
print 'a 变量保存数据内存的地址是 %d ' %id(a)
test(a)

# 定义了一个函数，准备了一个叫num的变量，引用的是数字10的内存地址
def test(num):
    print '在函数内部 %d 对应的内存地址是 %d' % (num,id(num))
# 定义了一个字符串变量
    result='hello'
    print '函数要返回的内存地址是 %d ' % id(result)
    return result
a=10
print 'a 变量保存数据内存的地址是 %d ' %id(a)
r = test(a)
print '%s的内存地址是 %d' %(r,id(r))

装饰器

概念：把一个函数当作参数，传递给函数

返回一个加强版的函数

本质上是一个返回函数的函数

“在不改变原函数的基础上，给函数增加功能”

def func1():
    print 'have a nice day'
def func2():
    print 'hahahahahhaahahah'
# outer()将传递进来的函数装饰，然后返回装饰好了的函数，
# 形参的作用是将装饰器公用
def outer(func):
    def inner():
        print '************'
        func()
    # 将装饰好的函数返回
    return inner
# f是func1的加强版，其实就是inner()
f = outer(func1)
f()
g = outer(func2)
g()

def old(age):
    print " man age is %d " % age
def outer(func):
    def inner(age):
        if age < 0:
            age = 0
        func(age)
    return inner
age = outer(old)
age(2)

装饰器标准格式

def outer(func):
    def inner(age):
        if age < 0:
            age = 0
        func(age)
    return inner
@outer
def old(age):
    print " man age is %d " % age
old(-1)

def outer(func):
    def inner(*args):
        print '#############'
        func(*args)
        print '@@@@@@@@@@@@@@@@@@@'
    return inner


@outer
def say(name,age):
    print 'my name is %s,i am %d years old' % (name,age)
say('haha',18)

def outer(func):
    def inner():
        print '############'
        func()
        print '@@@@@@@@@@@@@'
    return inner

@outer
def demo1():
    print 'demo1=====>'
demo1()

def outer(func1):
    def inner(arg):
        print 'hahaahha'
        result= func1(arg)
        print 'hehehehehe'
        return result
    return inner
@outer
def func1(arg):
    print 'func1',arg
    print '^^^^^^^^^'
    return 'return'
response = func1('westos')
print response

列表

列表

我们引入一个新的概念：数据机构

数据结构是通过某种方式组织在一起的数据元素的集合，这些数据元素可以是数字或字符，甚至可以是其他数据结构 >，在 python 中，最基本的数据结构是序列，序列中的每个元素匾被分配一个序号–即元素的位置，也称为索引，第一 > 个索引是 0，第二个则是 1，以此类推

列表是什么

列表由一系列特定顺序排列的元素组成，你可以创建包含字母表中所有字母，数字或所有家庭成员姓名的列表；也可 > 以将任何东西加入列表中，其中的元素之间可以没有任何关系

In [1]: bicycles = 'bmw'

In [2]: bicycles1 = 'bmw'

In [3]: bicycles2 = 'trek'

In [4]: bicycles3 = 'readline'

In [5]: bicycles
Out[5]: 'bmw'

In [6]: bicycles1
Out[6]: 'bmw'

In [7]: bicycles2
Out[7]: 'trek'

In [8]: bicycles3
Out[8]: 'readline'

In [9]: bicycles = ['bmw','trek','readline']

In [10]: type(bicycles)
Out[10]: list

In [11]: bicycles[0]
Out[11]: 'bmw'

In [12]: bicycles[1]
Out[12]: 'trek'

In [13]: bicycles[2]
Out[13]: 'readline'

In [14]: name_list.
  File "", line 1
    name_list.
              ^
SyntaxError: invalid syntax


In [15]: name_list = []

In [16]: name_list.
name_list.append   name_list.index    name_list.remove   
name_list.count    name_list.insert   name_list.reverse  
name_list.extend   name_list.pop      name_list.sort     

In [16]: spam = ['hello','hi','cat','dog']

In [17]: type(spam)
Out[17]: list

In [18]: spam.index('hello')
Out[18]: 0

In [19]: spam.index('hi')
Out[19]: 1

In [20]: spam.index('cat')
Out[20]: 2

In [21]: spam.index('dog')
Out[21]: 3

Python 列表 (List)

序列是 Python 中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是 0，第二个索引是 1，依此类推。

Python 有 6 个序列的内置类型，但最常见的是列表和元组。

序列都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = [‘physics’, ‘chemistry’, 1997, 2000]

list2 = [1, 2, 3, 4, 5]

list3 = [“a”, “b”, “c”, “d”]

与字符串的索引一样，列表索引从 0 开始。列表可以进行截取、组合等

访问列表中的值

使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]

print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]
以上实例输出结果：
list1[0]:  physics
list2[1:5]:  [2, 3, 4, 5]

Python 列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
如下所示：
Python 表达式                  结果                              描述
len([1, 2, 3])                  3                               长度
[1, 2, 3] + [4, 5, 6]           [1, 2, 3, 4, 5, 6]              组合
['Hi!'] * 4                     ['Hi!', 'Hi!', 'Hi!', 'Hi!']    重复
3 in [1, 2, 3]                  True                            元素是否存在于列表中
for x in [1, 2, 3]: print x,    1 2 3                           迭代

bicycles = ['bmw','trek','readline']
print bicycles






# 修改
bicycles = ['bmw','trek','readline']
print bicycles
bicycles[0] = 'trek'
print bicycles



更新列表
你可以对列表的数据项进行修改或更新，你也可以使用 append() 方法来添加列表项
# 添加列表元素,添加到末尾
bicycles = ['bmw','trek','readline']
print bicycles
bicycles.append('hai')
print bicycles

motorcycles = []
print motorcycles
motorcycles.append('honda')
print motorcycles
motorcycles.append('yamaha')
print motorcycles
motorcycles.append('bwm')
print motorcycles

num = [1,2,3,4,5,6]
print num
num.insert(3,'five')
print num

Python 列表截取
Python 的列表截取实例如下：
>>>L = ['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['Runoob', 'Taobao']
>>>
描述：
Python 表达式          结果                          描述
L[2]                'Taobao'                        读取列表中第三个元素
L[-2]               'Runoob'                        读取列表中倒数第二个元素
L[1:]               ['Runoob', 'Taobao']            从第二个元素开始截取列表

num = [1,2,3,4,5,6]
print num
num.insert(3,'five')
print num



# extent:把另外一个列表的完整内容追加到当前列表的末尾
bicycles = ['bmw','trek','readline']
num = [1,2,3,4]
bicycles.extend(num)
print bicycles



# del关键字，本质上是将一个变量从内存中删除
bicycles = ['bmw','trek','readline']
print bicycles
del bicycles[1]
print bicycles



# pop()弹出列表末尾一个元素
bicycles = ['bmw','trek','readline']
bicycles.pop()
print bicycles



bicycles = ['bmw','trek','readline']
bicycles.remove('bmw')
print bicycles

cars = ['bmw','audi','toyoto','subaru']
# len()获得列表的长度
# print len(cars)
# count：可以统计列表中某一个元素出现的次数
print cars.count('bmw')
# remove方法，默认删除列表中出现的第一个元素
# （此元素在列表中不唯一）
# 如果想不起来方法怎么用，
# 将鼠标放在方法名上ctrl+q
cars.remove('bmw')
print cars

Python 包含以下方法:
序号  方法
1   list.append(obj)
在列表末尾添加新的对象
2   list.count(obj)
统计某个元素在列表中出现的次数
3   list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4   list.index(obj)
从列表中找出某个值第一个匹配项的索引位置
5   list.insert(index, obj)
将对象插入列表
6   list.pop([index=-1])
移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7   list.remove(obj)
移除列表中某个值的第一个匹配项
8   list.reverse()
反向列表中元素
9   list.sort(cmp=None, key=None, reverse=False)
对原列表进行排序

# sort()对列表中的元素进行排序
name = ['wang','liu','qin','qiang','sun']
print name
name.sort()
print name

# sort(reverse=True) 对列表中的元素倒着排序
name = ['wang','liu','qin','qiang','sun']
print name
name.sort(reverse=True)
print name

# print sorted(name)临时对列表中的元素进行排序
name = ['wang','liu','qin','qiang','sun']
print name
print sorted(name)
print name


# reverse() 倒着打印列表元素，不排序
name = ['wang','liu','qin','qiang','sun']
print name
name.reverse()
print name

# 循环打印列表
name = ['wang','liu','qin','qiang','sun']
# names是随便起的名字
for names in name:
    # 缩进内部是循环
    print names
# 缩进外部与内部无关
print name
# 缩进外部打印的是循环完成的，即最后一次循环的字符
print names

# 打印数字 1-5
for abc in range(1,6):
    print abc
# 打印列表为1-5 [1, 2, 3, 4, 5]
nums = list(range(1,6))
print nums

# 打印列表2-10，步长为2，[2, 4, 6, 8, 10]
num = list(range(2,11,2))
print num

# 列表内数字简单运算，先定义一个空列表
squares = []
# 定义列表内容
for values in range(2,11,2):
    # 用一个中间变量用来计算
    square = values ** 3
    # 将计算好的中间变量导入列表
    squares.append(square)
print squares