python随笔

最新推荐文章于 2024-04-30 23:29:19 发布

cookie jar

最新推荐文章于 2024-04-30 23:29:19 发布

阅读量140

点赞数

分类专栏：笔记文章标签： python pycharm 爬虫

原文链接：http://c.biancheng.net/python/list_tuple_dict/

版权

笔记专栏收录该内容

9 篇文章 0 订阅

订阅专栏

Python 序列（Sequence）是指按特定顺序依次排列的一组数据，它们可以占用一块连续的内存，也可以分散到多块内存中。Python 中的序列类型包括列表（list）、元组（tuple）、字典（dict）和集合（set）。

在 Python 编程中，我们既需要独立的变量来保存一份数据，也需要序列来保存大量数据。

列表（list）和元组（tuple）比较相似，它们都按顺序保存元素，所有的元素占用一块连续的内存，每个元素都有自己的索引，因此列表和元组的元素都可以通过索引（index）来访问。它们的区别在于：列表是可以修改的，而元组是不可修改的。

字典（dict）和集合（set）存储的数据都是无序的，每份元素占用不同的内存，其中字典元素以 key-value 的形式保存。
http://c.biancheng.net/python/list_tuple_dict/

Python 中，可以使用 in 关键字检查某元素是否为序列的成员，其语法格式为：

value in sequence
其中，value 表示要检查的元素，sequence 表示指定的序列。

    str="abcd"
    print('a'in str)

在这里插入图片描述
列表[list]：功能更强大的数组。

对于已经创建的列表，如果不再使用，可以使用del关键字将其删除。

实际开发中并不经常使用 del 来删除列表，因为 Python 自带的垃圾回收机制会自动销毁无用的列表，即使开发者不手动删除，Python 也会自动将其回收。

del 关键字的语法格式为：

del listname
其中，listname 表示要删除列表的名称。

列表中添加元素：

+号，两个列表相加，形成一个新的列表
append() 方法用于在列表的末尾追加元素，该方法的语法格式如下：listname.append(obj),可以添加单个元素或者列表和数组
extend()方法添加元素； listname.extend(obj)其中，listname 指的是要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等，但不能是单个的数字。
insert()方法插入元素； listname.insert(index , obj)，其中**，index 表示指定位置的索引值**【这个索引从0开始数】。insert() 会将 obj 插入到 listname 列表第 index 个元素的位置。
append() 和 extend() 方法只能在列表末尾插入元素，如果希望在列表中间某个位置插入元素，那么可以使用 insert() 方法。

在 Python 列表中删除元素
主要分为以下 3 种场景：

根据目标元素所在位置的索引进行删除，可以使用 del 关键字或者 pop() 方法；
根据元素本身的值进行删除，可使用列表（list类型）提供的 remove() 方法；
将列表中所有元素全部删除，可使用列表（list类型）提供的 clear() 方法。

列表在修改元素的时候，不是一对一的，具体请看下面的例子：

nums = [40, 36, 89, 2, 36, 100, 7]

#修改第 1~4 个元素的值（不包括第4个元素）
nums[1: 4] = [45.25, -77, -52.5,5,6,7]
print(nums)

如果对空切片（slice）赋值，就相当于插入一组新的元素：

   nums = [40, 36, 89, 2, 36, 100, 7]
    #在4个位置插入元素
    nums[4: 4] = [-77, -52.5, 999]
    print(nums)

使用切片语法时也可以指定步长（step 参数），但这个时候就要求所赋值的新元素的个数与原有元素的个数相同，例如： `

    nums = [40, 36, 89, 2, 36, 100, 7]
    #步长为2，为第1、3、5个元素赋值
    nums[1: 6: 2] = [0.025, -99, 20.5]
    print(nums)

Python 列表（list）提供了 index() 和 count() 方法，它们都可以用来查找元素。
index() 方法
index() 方法用来查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致 ValueError 错误，所以在查找之前最好使用 count() 方法判断一下。

index() 的语法格式为：

listname.index(obj, start, end)

count() 方法用来统计某个元素在列表中出现的次数，基本语法格式为：

listname.count(obj)
其中，listname 代表列表名，obj 表示要统计的元素。

如果 count() 返回 0，就表示列表中不存在该元素，所以 count() 也可以用来判断列表中的某个元素是否存在。

元组（tuple)：
元组和列表（list）的不同之处在于：

列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；
而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。*元组也可以看做是不可变的列表*

在 Python 中，元组通常都是使用一对小括号将所有元素包围起来的，但小括号不是必须的，只要将各元素用逗号隔开，Python 就会将其视为元组，请看下面的例子：

    course = "Python教程", "http://c.biancheng.net/python/"
    print(course)

在这里插入图片描述
2) 使用tuple()函数创建元组
除了使用( )创建元组外，Python 还提供了一个内置的函数 tuple()，用来将其它数据类型转换为元组类型。

tuple() 的语法格式如下：

tuple(data)
其中，data 表示可以转化为元组的数据，包括字符串、元组、range 对象等。

修改元组：
1.可以给它重新赋值
2.可以进行元组的拼接，但是拼接不会改变原来元组的值，只是会生成一个新的元组。
在这里插入图片描述 dict字典
Python 字典（dict）是一种无序的、可变的序列，它的元素以“键值对（key-value）”的形式存储。相对地，列表（list）和元组（tuple）都是有序的序列，它们的元素在底层是挨着存放的。
字典类型是 Python 中唯一的映射类型。
各元素对应的索引称为键，各个键对应的元素称为值（value）
在这里插入图片描述 字典的键可以是整数、字符串或者元组，只要符合唯一和不可变的特性就行；字典的值可以是 Python 支持的任意数据类型。

1.Python 中，还可以使用 dict 字典类型提供的 fromkeys() 方法创建带有默认值的字典，具体格式为：

dictname = dict.fromkeys(list，value=None)
其中，list 参数表示字典中所有键的列表（list）；value 参数表示默认值，如果不写，则为空值 None。
2.通过 dict() 映射函数创建字典
在这里插入图片描述 1.Python 访问字典元素的具体格式为：

dictname[key]
其中，dictname 表示字典变量的名字，key 表示键名。注意，键必须是存在的，否则会抛出异常。

2.Python 更推荐使用 dict 类型提供的 get() 方法来获取指定键对应的值。当指定的键不存在时，get() 方法不会抛出异常。

get() 方法的语法格式为：

dictname.get(key[,default])
其中，dictname 表示字典变量的名字；key 表示指定的键；default 用于指定要查询的键不存在时，此方法返回的默认值，如果不手动指定，会返回 None。

a = dict(two=0.65, one=88, three=100, four=-59)
print( a.get('one')

Python字典添加键值对
为字典添加新的键值对很简单，直接给不存在的 key 赋值即可，具体语法格式如下：
dictname[key] = value

Python字典修改键值对
Python 字典中键（key）的名字不能被修改，我们只能修改值（value）。

字典中各元素的键必须是唯一的，因此，如果新添加元素的键与已存在元素的键相同，那么键所对应的值就会被新的值替换掉，以此达到修改元素值的目的。

判断字典中是否存在指定键值对
如果要判断字典中是否存在指定键值对，首先应判断字典中是否有对应的键。判断字典是否包含指定键值对的键，可以使用 in 或 not in 运算符。

需要指出的是，对于 dict 而言，in 或 not in 运算符都是基于 key 来判断的。

    a = {'数学': 95, '语文': 89, '英语': 90}
    # 判断 a 中是否包含名为'数学'的key
    print('数学' in a) # True
    # 判断 a 是否包含名为'物理'的key
    print('物理' in a) # False

keys()、values() 和 items() 方法
将这三个方法放在一起介绍，是因为它们都用来获取字典中的特定数据：

keys() 方法用于返回字典中的所有键（key）；
values() 方法用于返回字典中所有键对应的值（value）；
items() 用于返回字典中所有的键值对（key-value）。

    scores = {'数学': 95, '语文': 89, '英语': 90}
    print(scores.keys())
    print(scores.values())
    print(scores.items())

输出：dict_keys([‘数学’, ‘语文’, ‘英语’])
dict_values([95, 89, 90])
dict_items([(‘数学’, 95), (‘语文’, 89), (‘英语’, 90)])`

在这里插入图片描述
pop() 和 popitem() 都用来删除字典中的键值对，不同的是，pop() 用来删除指定的键值对，而 popitem() 用来随机删除一个键值对，它们的语法格式如下：

dictname.pop(key)
dictname.popitem()
其中，dictname 表示字典名称，key 表示键。
其实，说 popitem() 随机删除字典中的一个键值对是不准确的，虽然字典是一种无须的列表，但键值对在底层也是有存储顺序的，popitem() 总是弹出底层中的最后一个 key-value，这和列表的 pop() 方法类似，都实现了数据结构中“出栈”的操作。

Python 中的集合，和数学中的集合概念一样，用来保存不重复的元素，即集合中的元素都是唯一的，互不相同。
同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型，否则 Python 解释器会抛出 TypeError 错误

Python 中，无论是 while 循环还是 for 循环，其后都可以紧跟着一个 else 代码块，它的作用是当循环条件为 False 跳出循环时，程序会最先执行 else 代码块中的代码。

在创建函数时，即使函数不需要参数，也必须保留一对空的“()”，否则 Python 解释器将提示“invaild syntax”错误。另外，如果想定义一个没有任何功能的空函数，可以使用 pass 语句作为占位符。

但需要注意，混合传参时关键字参数必须位于所有的位置参数之后。也就是说，如下代码是错误的：

# 位置参数必须放在关键字参数之前，下面代码错误
dis_str(str1="http://c.biancheng.net/python/","http://c.biancheng.net/shell/")

在使用此格式定义函数时，指定有默认值的形式参数必须在所有没默认值参数的最后，否则会产生语法错误。

#str1没有默认参数，str2有默认参数
def dis_str(str1,str2 = “http://c.biancheng.net/python/”):

Pyhton 中，可以使用“函数名.defaults”查看函数的默认值参数的当前值，其返回值是一个元组。以本节中的 dis_str() 函数为例，在其基础上，执行如下代码：

print(dis_str.__defaults__)

对于所有没有 return 语句的函数定义，Python 都会在末尾加上 return None，使用不带值的 return 语句（也就是只有 return 关键字本身），那么就返回 None。

在函数体内定义全局变量。即用 global 关键字对变量进行修饰后，该变量就会变为全局变量。例如：

    def text():
        global add
        add= "http://c.biancheng.net/java/"
        print("函数体内访问：",add)
    text()
    print('函数体外访问：',add)

```获取指定作用域范围中的变量

globals()函数
globals() 函数为 Python 的内置函数，它可以返回一个包含全局范围内所有变量的字典，该字典中的每个键值对，键为变量名，值为该变量的值。

    #全局变量
    Pyname = "Python教程"
    Pyadd = "http://c.biancheng.net/python/"
    def text():
        #局部变量
        Shename = "shell教程"
        Sheadd= "http://c.biancheng.net/shell/"
    print(globals())

程序执行结果为：

{ … , ‘Pyname’: ‘Python教程’, ‘Pyadd’: ‘http://c.biancheng.net/python/’, …}

【globals() 函数返回的字典中，会默认包含有很多变量，这些都是 Python 主程序内置的】

    print(globals()['Pyname'])
    globals()['Pyname'] = "Python入门教程"
    print(Pyname)

通过调用 globals() 函数，我们可以得到一个包含所有全局变量的字典。并且，通过该字典，我们还可以访问指定变量，甚至如果需要，还可以修改它的值。
、

2) locals()函数
locals() 函数也是 Python 内置函数之一，通过调用该函数，我们可以得到一个包含当前作用域内所有变量的字典。这里所谓的“当前作用域”指的是，在函数内部调用 locals() 函数，会获得包含所有局部变量的字典；而在全局范文内调用 locals() 函数，其功能和 globals() 函数相同。

   print(locals())

locals() 返回的局部变量组成的字典，可以用来访问变量，但无法修改变量的值。

3) vars(object)
vars() 函数也是 Python 内置函数，其功能是返回一个指定 object 对象范围内所有变量组成的字典。如果不传入object 参数，vars() 和 locals() 的作用完全相同。

     #全局变量
    Pyname = "Python教程"
    Pyadd = "http://c.biancheng.net/python/"
    class Demo:
        name = "Python 教程"
        add = "http://c.biancheng.net/python/"
    print("有 object：")
    print(vars(Demo))
    print("无 object：")
    print(vars())

执行结果：

有 object：
{...... , 'name': 'Python 教程', 'add': 'http://c.biancheng.net/python/', ......}
无 object：
{...... , 'Pyname': 'Python教程', 'Pyadd': 'http://c.biancheng.net/python/', ...... }

Python 支持在函数内部定义函数，此类函数又称为局部函数。

对于局部函数的作用域，可以总结为：如果所在函数没有返回局部函数，则局部函数的可用范围仅限于所在函数内部；反之，如果所在函数将局部函数作为返回值，则局部函数的作用域就会扩大，既可以在所在函数内部使用，也可以在所在函数的作用域中使用。

在当前作用域/代码块中，一个变量如果没有用关键字global或者nonlocal声明，则是局部变量，否则它是一个全局（global）变量或者是外层作用域的非局部（nonlocal）变量。

python中引用变量的顺序：当前作用域局部变量->外层作用域变量->当前模块中的全局变量->python内置变量

**闭包，又称闭包函数或者闭合函数，**其实和前面讲的嵌套函数类似，不同之处在于，闭包中外部函数返回的不是一个具体的值，而是一个函数。一般情况下，返回的函数会赋值给一个变量，这个变量可以在后面被继续执行调用。

    #闭包函数，其中 exponent 称为自由变量
    def nth_power(exponent):
        def exponent_of(base):
            return base ** exponent
        return exponent_of # 返回值是 exponent_of 函数
    square = nth_power(2) # 计算一个数的平方
    cube = nth_power(3) # 计算一个数的立方
    print(square(2))  # 计算 2 的平方
    print(cube(2)) # 计算 2 的立方

使用闭包，可以让程序变得更简洁易读

    # 不使用闭包
    res1 = nth_power_rewrite(base1, 2)
    res2 = nth_power_rewrite(base2, 2)
    res3 = nth_power_rewrite(base3, 2)
    # 使用闭包
    square = nth_power(2)
    res1 = square(base1)
    res2 = square(base2)
    res3 = square(base3)

缩减嵌套函数的优点类似，函数开头需要做一些额外工作，当需要多次调用该函数时，如果将那些额外工作的代码放在外部函数，就可以减少多次调用导致的不必要开销，提高程序的运行效率

闭包比普通的函数多了一个 closure 属性，该属性记录着自由变量的地址。当闭包被调用时，系统就会根据该地址找到对应的自由变量，完成整体的函数调用。

以 nth_power() 为例，当其被调用时，可以通过 closure 属性获取自由变量（也就是程序中的 exponent 参数）存储的地址，例如：

    def nth_power(exponent):
        def exponent_of(base):
            return base ** exponent
        return exponent_of
    square = nth_power(2)
    #查看 __closure__ 的值
    print(square.__closure__)

在这里插入图片描述

cookie jar

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python随笔

Python 序列（Sequence）是指按特定顺序依次排列的一组数据，它们可以占用一块连续的内存，也可以分散到多块内存中。Python 中的序列类型包括列表（list）、元组（tuple）、字典（dict）和集合（set）。在 Python 编程中，我们既需要独立的变量来保存一份数据，也需要序列来保存大量数据。列表（list）和元组（tuple）比较相似，它们都按顺序保存元素，所有的元素占用一块连续的内存，每个元素都有自己的索引，因此列表和元组的元素都可以通过索引（index）来访问。它们的区别在于：
复制链接

扫一扫