威尼斯人线上娱乐

函数详解及实例,python内置类别类型

21 4月 , 2019  

目  录

 

python高端(一)——
python数据模型(特殊措施)

python高端(二)——
python内置种类类型

python高端(3)——
字典和集纳(泛映射类型)

函数详解及实例,python内置类别类型。python高等(四)——
文本和字节系列(编码难点)

python高档(5)——
python函数(一等对象)

python高档(6)——用一等函数达成设计情势

 

未完……(周周更新一两篇,共约20篇)

 

 

 

正文首要内容

  连串类型分类:

    (一)容器系列、扁平体系

    (2)可变类别、不可变种类

  列表推导式

  生成器表明式

  元组拆包

  切片

  排序(list.sort方法和sorted函数)

  bisect

 

python高级——目录

  文中代码均位居github上:https://github.com/ampeeg/cnblogs/tree/master/python高级

 

python高档(贰)—— python内置种类类型,python内置体系类型

python 迭代器和iter()函数详解及实例,pythoniter

python中迭代器和iter()函数

迭代器为类体系对象提供了2个类连串的接口。python的迭代无缝地帮衬种类对象,而且它还同意程序猿迭代非系列类型,包蕴用户定义的对象。迭代器用起来很利索,你可以迭代不是种类但显示处连串行为的对象,举个例子字典的键、一个文书的行,等等。迭代器的成效如下:

•提供了刻扩充的迭代器接口;
•对列表迭代带来了品质上的增加;
•在字典迭代中品质提高;
•创造真正的迭代接口,而不是本来的跟着对象访问;
•与持有曾经存在的用户定义的类以及扩张得模拟类别和照耀的对象向后卓越;
威尼斯人线上娱乐,•迭代非系列集结(比方映射和文件)时,能够创设越来越精简可读的代码

#iter and generator
#the first try
#=================================
i = iter('abcd')
print i.next()
print i.next()
print i.next()

s = {'one':1,'two':2,'three':3}
print s
m = iter(s)
print m.next()
print m.next()
print m.next()

D:\Scirpt\Python\Python高端编程>python ch2_2.py

a
b
c
{'three': 3, 'two': 2, 'one': 1}
three
two
one

谢谢阅读,希望能扶助到大家,多谢大家对本站的匡助!

迭代器和iter()函数详解及实例,pythoniter
python中迭代器和iter()函数
迭代器为类种类对象提供了1个类体系的接口。python的迭代无缝地支…

队列类型分类

 

   所谓序列,即成分有序排列,python标准库用C完成了增加的队列类型,依据连串中是或不是可存放分裂类别的数量分为”容器连串”和”扁平种类”。

  容器种类能够存放统统类型的数据,而扁平种类只可以存放一种档次     

    容器序列:list、tuple、collections.deque   
    扁平序列:str、bytes、bytearray、memoryview、array.array
  
  按照是否能修改的标准序列又可分为"可变序列"和"不可变序列":      
    可变序列:list、bytearrary、array.arrary、collections.deque和memoryview   
    不可变序列:tuple、str和bytes

  由于可变序列继承自不可变序列,所以可变序列继承的方法也较多,下面看看它们包含的方法:   
方法名 不可变序列 可变序列
__contains__  有 有 
__iter__  有  有 
 __len__  有  有 
__getitem__   有  有 
__reversed__   有  有 
index   有  有 
count   有  有 
__setitem__    有 
__delitem__   有 
insert   有 
append   有 
reverse   有 
extend   有 
pop   有 
remove   有 
__iadd__    有 

  

  我们以tuple和list类型为例,比较源代码中的方法,能够显明发掘list的措施多于tuple:

  

威尼斯人线上娱乐 1

 

正文主要内容

  种类类型分类:

    (壹)容器种类、扁平类别

    (二)可变系列、不可变类别

  列表推导式

  生成器表达式

  元组拆包

  切片

  排序(list.sort方法和sorted函数)

  bisect

 

  文中代码均位于github上:

 

列表推导式

# 列表推导式生成的是列表,会占用系统内存
# 基本语法

list_1 = [x for x in range(1, 20)]
list_2 = [x ** 2 for x in range(1, 20)]


print(list_1)  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
print(list_2)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361]

# 笛卡尔积型的列表推导式
list_3 = [(x, y) for x in range(1, 3)        # 1,2
                 for y in range(7, 10)]      # 7、8、9

                                             # 该表达式会先将1分别和7、8、9组合,然后再拿2和7、8、9组合,共6对
print(list_3)  # [(1, 7), (1, 8), (1, 9), (2, 7), (2, 8), (2, 9)]


list_4 = [x+y for x in range(1, 3)
                 for y in range(7, 10)]

print(list_4)   # [8, 9, 10, 9, 10, 11]

# 还可以添加if语句
l = [1, 3, 4, 33, 45, 36, 422, 34, 67, 23, -4, -7, -345, 46, -6, -45, 32, -8, -4, 67, -4]

list_5 = [x for x in l if x > 0]   # 只取出大于0的生成列表
print(list_5)                      # [1, 3, 4, 33, 45, 36, 422, 34, 67, 23, 46, 32, 67]

 

队列类型分类

 

   所谓连串,即成分有序排列,python规范库用C达成了拉长的行列类型,依照体系中是还是不是可存放差异品种的多寡分为”容器连串”和”扁平连串”。

  容器类别可以存放统统类型的多少,而扁平类别只好存放①种档案的次序      

    容器序列:list、tuple、collections.deque   
    扁平序列:str、bytes、bytearray、memoryview、array.array
  
  按照是否能修改的标准序列又可分为"可变序列"和"不可变序列":      
    可变序列:list、bytearrary、array.arrary、collections.deque和memoryview   
    不可变序列:tuple、str和bytes

  由于可变序列继承自不可变序列,所以可变序列继承的方法也较多,下面看看它们包含的方法:   
方法名 不可变序列 可变序列
__contains__  有 有 
__iter__  有  有 
 __len__  有  有 
__getitem__   有  有 
__reversed__   有  有 
index   有  有 
count   有  有 
__setitem__    有 
__delitem__   有 
insert   有 
append   有 
reverse   有 
extend   有 
pop   有 
remove   有 
__iadd__    有 

  

  我们以tuple和list类型为例,相比源代码中的方法,能够显明开掘list的办法多于tuple:

  

 

生成器表达式

# 虽然列表推导式可以用来初始化元组、数组或其他序列类型,但是列表推导式会直接生成列表,占用内存
# 而生成器遵守了迭代器协议,可以逐个产出元素,而不是先建立一个完整的列表


# 生成器表达式直接将推导式的方括号换成圆括号即可

g = (x for x in range(1, 10000))

print(g)    # <generator object <genexpr> at 0x105c0efc0> :生成器对象


from collections import Iterable, Iterator

if isinstance(g, Iterable):
    print("iterable")          # 输出iterable: 说明生成器g是可迭代的

if isinstance(g, Iterator):
    print("iterator")          # 输出iterator:说明生成器g是迭代器

 

  下边我们来对待一下列表推导式和生成器的频率

# 比较列表推导式和生成器
import time

start_time = time.time()
l = [x for x in range(1000000)]
print(time.time() - start_time)     # 0.1361069679260254

start_time = time.time()
g = (x for x in range(1000000))
print(time.time() - start_time)     # 1.1205673217773438e-05

# 可见,生成器远快于推导式

 

列表推导式

# 列表推导式生成的是列表,会占用系统内存
# 基本语法

list_1 = [x for x in range(1, 20)]
list_2 = [x ** 2 for x in range(1, 20)]


print(list_1)  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
print(list_2)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361]

# 笛卡尔积型的列表推导式
list_3 = [(x, y) for x in range(1, 3)        # 1,2
                 for y in range(7, 10)]      # 7、8、9

                                             # 该表达式会先将1分别和7、8、9组合,然后再拿2和7、8、9组合,共6对
print(list_3)  # [(1, 7), (1, 8), (1, 9), (2, 7), (2, 8), (2, 9)]


list_4 = [x+y for x in range(1, 3)
                 for y in range(7, 10)]

print(list_4)   # [8, 9, 10, 9, 10, 11]

# 还可以添加if语句
l = [1, 3, 4, 33, 45, 36, 422, 34, 67, 23, -4, -7, -345, 46, -6, -45, 32, -8, -4, 67, -4]

list_5 = [x for x in l if x > 0]   # 只取出大于0的生成列表
print(list_5)                      # [1, 3, 4, 33, 45, 36, 422, 34, 67, 23, 46, 32, 67]

 

元组拆包

# 我们经常这样给两个变量同时赋值
a, b = 1, 2
print(a, b)     # 1 2

# 还可以这样
a, b = [1, 2]
print(a, b)     # 1 2

# 也可以这样
a, b = (1, 2)
print(a, b)     # 1 2

# 甚至可以这样
a, b = "ab"
print(a, b)     # a b

'''
    像以上这样连续的赋值方式,右边可以使用逗号隔开;也可以是序列。

    当拆包赋值的是序列时,python解释器会先找该序列中的__iter__方法,如果该方法不存在,则寻找__getitem__方法。

    接下来说其他用法
'''

# 赋值后优雅地交换两个变量
a, b = (1, 2)
a, b = b, a
print(a, b)        # 2 1

# 使用*号来处理多余的数据
a, b, *s = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(a, b, s)        # 1 2 [3, 4, 5, 6, 7, 8, 9]
                      # 这样从第三个元素开始的所有值都赋给了s

a, b, *s = (1, 2, 3, 4, 5, 6, 7, 8, 9)
print(a, b, s)        # 1 2 [3, 4, 5, 6, 7, 8, 9]
                      # 注意,本来是元组,赋之后的s变成了列表. 如果s为空的话也会返回空列表

*s, a, b = (1, 2, 3, 4, 5, 6, 7, 8, 9)
print(s, a, b)        # [1, 2, 3, 4, 5, 6, 7] 8 9
                      # *s也可以放在前面

a, *s, b = (1, 2, 3, 4, 5, 6, 7, 8, 9)
print(a, s, b)        # 1 [2, 3, 4, 5, 6, 7, 8] 9
                      # *s也可以放在中间

# 嵌套元组拆包
a, b, (c, d) = (1, 2, (3, 4))
print(a, b, c, d)     # 1 2 3 4
                      # 只要按照右边的形式就可赋值

a, b, *c = (1, 2, (3, 4))
print(a, b, c)     # 1 2 [(3, 4)]

 

威尼斯人线上娱乐 2威尼斯人线上娱乐 3

 1 ################################
 2 #
 3 # 以下的例子用以说明拆包赋值时,解释器会按照__iter__、__getitem__的顺序调用类中的方法
 4 #
 5 ################################
 6 class Foo:
 7     def __init__(self, s):
 8         self.s = s
 9 
10     def __iter__(self):
11         print("iter")
12         return iter(self.s)
13 
14     def __getitem__(self, item):
15         return self.s[item]
16 
17 if __name__ == "__main__":
18     foo = Foo("sdfafasfasf")
19     a, b, *s = foo
20     print(a, b)

拆包赋值的内部贯彻

 

  在此之前大家因此源码已经相比过list和tuple类中的方法和属性,下边列出《流畅的python》整理的列表和元组的不二等秘书诀及品质:

表 列表或元组的办法和品质

  列  表 元  组
s.__add__(s2)
· ·
s.__iadd__(s2) ·  
s.append(e) ·  
s.clear() ·  
s.__contains__(e) · ·
s.copy() ·  
s.count(e) · ·
s.__delitem__(p) ·  
s.extend(it) ·  
s.__getitem__(p) · ·
s.__getnewargs__()   ·
s.index(e) · ·
x.insert(p,e) ·  
s.__iter__() · ·
s.__len__() · ·
s.__mul__(n) · ·
s.__imul__(n) ·  
s.__rmul__(n) · ·
s.pop([p]) ·  
s.remove(e) ·  
s.reverse() ·  
s.__reversed__() ·  
s.__setitem__(p,e) ·  
s.sort([key], [reverse]) ·  

   

  说明:以元夕组中不加黑点的不意味着一定不可能那样使用,只是其功用和列表分歧(表达里面有表达)。举个例子五个元组a和b实行增量赋值a+=b也是足以的,只是那么些操作不是就地拼接,而是生成了新的元组。

生成器表明式

# 虽然列表推导式可以用来初始化元组、数组或其他序列类型,但是列表推导式会直接生成列表,占用内存
# 而生成器遵守了迭代器协议,可以逐个产出元素,而不是先建立一个完整的列表


# 生成器表达式直接将推导式的方括号换成圆括号即可

g = (x for x in range(1, 10000))

print(g)    # <generator object <genexpr> at 0x105c0efc0> :生成器对象


from collections import Iterable, Iterator

if isinstance(g, Iterable):
    print("iterable")          # 输出iterable: 说明生成器g是可迭代的

if isinstance(g, Iterator):
    print("iterator")          # 输出iterator:说明生成器g是迭代器

 

  下边大家来对待一下列表推导式和生成器的频率

# 比较列表推导式和生成器
import time

start_time = time.time()
l = [x for x in range(1000000)]
print(time.time() - start_time)     # 0.1361069679260254

start_time = time.time()
g = (x for x in range(1000000))
print(time.time() - start_time)     # 1.1205673217773438e-05

# 可见,生成器远快于推导式

 

切片

'''
    在python中,内置的序列类型都支持切片操作,切片操作的用法十分简单:
    list[start: stop: step]    , 其中不包括区间范围内最后一个(事实上这是python的风格,一般不包含区间最后一个)
    python里面能使用切片操作是因为实现了__getitem__方法,切片时会给该方法传递slice(start: stop: step) 参数
'''

if __name__ == "__main__":
    # 基本操作
    l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    print(l[2:])     # 第3个元素到最后   :[3, 4, 5, 6, 7, 8, 9]
    print(l[:3])     # 第一个元素到最后   :[1, 2, 3]

    s = "abcdefghijklmn"
    print(s[2::2])   # 从第三个字母开始,隔一个字母取一个 : cegikm
    print(s[::-1])   # 倒序排列 : nmlkjihgfedcba
    print(s[::-2])   # 倒序隔一个取一个 nljhfdb
    print(s[-2::-2]) # 倒序第二隔开始,隔一个取一个

    # 利用切片赋值
    l[2:5] = [20, 30]
    print(l)         # [1, 2, 20, 30, 6, 7, 8, 9]
    try:
        l[2:5] = 40      # 报错:TypeError: can only assign an iterable
                         # 利用切片赋值时传入的必须是可迭代对象
    except Exception as e:
        print(e)         # can only assign an iterable
    l[2:5] = (40,)
    print(l)             # [1, 2, 40, 7, 8, 9]
    l[2:3] = "sajfljls"  # 字符串属于序列,也可以迭代
    print(l)             # [1, 2, 's', 'a', 'j', 'f', 'l', 'j', 'l', 's', 7, 8, 9]

 

元组拆包

# 我们经常这样给两个变量同时赋值
a, b = 1, 2
print(a, b)     # 1 2

# 还可以这样
a, b = [1, 2]
print(a, b)     # 1 2

# 也可以这样
a, b = (1, 2)
print(a, b)     # 1 2

# 甚至可以这样
a, b = "ab"
print(a, b)     # a b

'''
    像以上这样连续的赋值方式,右边可以使用逗号隔开;也可以是序列。

    当拆包赋值的是序列时,python解释器会先找该序列中的__iter__方法,如果该方法不存在,则寻找__getitem__方法。

    接下来说其他用法
'''

# 赋值后优雅地交换两个变量
a, b = (1, 2)
a, b = b, a
print(a, b)        # 2 1

# 使用*号来处理多余的数据
a, b, *s = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(a, b, s)        # 1 2 [3, 4, 5, 6, 7, 8, 9]
                      # 这样从第三个元素开始的所有值都赋给了s

a, b, *s = (1, 2, 3, 4, 5, 6, 7, 8, 9)
print(a, b, s)        # 1 2 [3, 4, 5, 6, 7, 8, 9]
                      # 注意,本来是元组,赋之后的s变成了列表. 如果s为空的话也会返回空列表

*s, a, b = (1, 2, 3, 4, 5, 6, 7, 8, 9)
print(s, a, b)        # [1, 2, 3, 4, 5, 6, 7] 8 9
                      # *s也可以放在前面

a, *s, b = (1, 2, 3, 4, 5, 6, 7, 8, 9)
print(a, s, b)        # 1 [2, 3, 4, 5, 6, 7, 8] 9
                      # *s也可以放在中间

# 嵌套元组拆包
a, b, (c, d) = (1, 2, (3, 4))
print(a, b, c, d)     # 1 2 3 4
                      # 只要按照右边的形式就可赋值

a, b, *c = (1, 2, (3, 4))
print(a, b, c)     # 1 2 [(3, 4)]

 

威尼斯人线上娱乐 4

 1 ################################
 2 #
 3 # 以下的例子用以说明拆包赋值时,解释器会按照__iter__、__getitem__的顺序调用类中的方法
 4 #
 5 ################################
 6 class Foo:
 7     def __init__(self, s):
 8         self.s = s
 9 
10     def __iter__(self):
11         print("iter")
12         return iter(self.s)
13 
14     def __getitem__(self, item):
15         return self.s[item]
16 
17 if __name__ == "__main__":
18     foo = Foo("sdfafasfasf")
19     a, b, *s = foo
20     print(a, b)

拆包赋值的内部贯彻

 

  以前大家因此源码已经相比较过list和tuple类中的方法和总体性,上面列出《流畅的python》整理的列表和元组的艺术及质量:

表 列表或元组的方法和性质

  列  表 元  组
s.__add__(s2) · ·
s.__iadd__(s2) ·  
s.append(e) ·  
s.clear() ·  
s.__contains__(e) · ·
s.copy() ·  
s.count(e) · ·
s.__delitem__(p) ·  
s.extend(it) ·  
s.__getitem__(p) · ·
s.__getnewargs__()   ·
s.index(e) · ·
x.insert(p,e) ·  
s.__iter__() · ·
s.__len__() · ·
s.__mul__(n) · ·
s.__imul__(n) ·  
s.__rmul__(n) · ·
s.pop([p]) ·  
s.remove(e) ·  
s.reverse() ·  
s.__reversed__() ·  
s.__setitem__(p,e) ·  
s.sort([key], [reverse]) ·  

   

  表明:以上元节组中不加黑点的不意味着一定无法这么使用,只是其作用和列表不相同(表明里面有表明)。比如五个元组a和b进行增量赋值a+=b也是足以的,只是这几个操作不是就地拼接,而是生成了新的元组。

排序(list.sort方法和sorted函数)

'''
    list.sort方法和sorted内置函数都有排序的功能,区别如下
        list.sort是就地排序列表,不会把原列表复制一份。该方法返回None,以提醒不会新建一个列表。
        sorted函数会新建一个列表作为返回值,这个函数可以接受任何可迭代对象,甚至包括不可变序列或生成器,最后返回的总是列表。

    list.sort和sorted都有两个参数:
        reverse:默认为False,设定为True以降序排列
        key:一个只有一个参数的函数,这个函数会作用于序列的每一个元素上,然后以该函数的结果作为关键字排序

'''

if __name__ == "__main__":
    # 1、list.sort就地排序,而sorted返回列表
    l = [x for x in range(10, 0, -1)]      # 初始化一个列表:[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
    print(id(l), l)    # l最初的地址:4536449800 [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
    l.sort()
    print(id(l), l)    # 排序后的地址:4536449800 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
                       # l前后的的地址没变,说明是就地排序


    l = [x for x in range(10, 0, -1)]  # 初始化一个列表:[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
    print(id(l), l)  # l最初的地址:4415318984 [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
    l = sorted(l)
    print(id(l), l)  # 排序后的地址:4415318792 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    # 2、sorted可以接受任何可迭代对象
    l = (x for x in range(10, 0, -1))
    print(type(l))        # 迭代器 <class 'generator'>
    print(sorted(l))      # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    s = "qwertyuiopasdfghjklzxcvbnm"   # 字符串序列
    print(sorted(s))      # ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

    s = (1, 3, 2, 456, 345, 12, 2, 5, 78, 34)   # 不可变元组
    print(sorted(s))      # [1, 2, 2, 3, 5, 12, 34, 78, 345, 456]

    # 3、reverse参数
    s = "qwertyuiopasdfghjklzxcvbnm"
    print(sorted(s, reverse=True))   # ['z', 'y', 'x', 'w', 'v', 'u', 't', 's', 'r', 'q', 'p', 'o', 'n', 'm', 'l', 'k', 'j', 'i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']


    # 4、key参数
    s = "QwERTYuioPaSdfGHjKLzXcvbnm"
    print(sorted(s))    # ['E', 'G', 'H', 'K', 'L', 'P', 'Q', 'R', 'S', 'T', 'X', 'Y', 'a', 'b', 'c', 'd', 'f', 'i', 'j', 'm', 'n', 'o', 'u', 'v', 'w', 'z']
    print(sorted(s, key=str.lower))   # 忽略大小写 ['a', 'b', 'c', 'd', 'E', 'f', 'G', 'H', 'i', 'j', 'K', 'L', 'm', 'n', 'o', 'P', 'Q', 'R', 'S', 'T', 'u', 'v', 'w', 'X', 'Y', 'z']
    print(sorted(s, key=str.upper))   # 也是忽略大小写

##########################
#
#  以下自定义一个类也可使用sorted函数
#
##########################

class Obj:
    def __init__(self):
        self.s = [x for x in range(10, 0, -1)]

    def __getitem__(self, item):
        print("getitem")
        return self.s[item]

    def __repr__(self):
        return str(self.s)

    def __iter__(self):
        return iter(self.s)

obj = Obj()
print(obj)           # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

# 添加getitem后可以使用sorted函数  (实验时请注视掉getitem方法)
print(sorted(obj))   #  打印10次getitem   , [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 添加iter方法
print(sorted(obj))   # 此时解释器会先调用iter方法,不会再使用getitem方法
                     # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

使自定义类也可使用sorted函数调用

 

切片

'''
    在python中,内置的序列类型都支持切片操作,切片操作的用法十分简单:
    list[start: stop: step]    , 其中不包括区间范围内最后一个(事实上这是python的风格,一般不包含区间最后一个)
    python里面能使用切片操作是因为实现了__getitem__方法,切片时会给该方法传递slice(start: stop: step) 参数
'''

if __name__ == "__main__":
    # 基本操作
    l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    print(l[2:])     # 第3个元素到最后   :[3, 4, 5, 6, 7, 8, 9]
    print(l[:3])     # 第一个元素到最后   :[1, 2, 3]

    s = "abcdefghijklmn"
    print(s[2::2])   # 从第三个字母开始,隔一个字母取一个 : cegikm
    print(s[::-1])   # 倒序排列 : nmlkjihgfedcba
    print(s[::-2])   # 倒序隔一个取一个 nljhfdb
    print(s[-2::-2]) # 倒序第二隔开始,隔一个取一个

    # 利用切片赋值
    l[2:5] = [20, 30]
    print(l)         # [1, 2, 20, 30, 6, 7, 8, 9]
    try:
        l[2:5] = 40      # 报错:TypeError: can only assign an iterable
                         # 利用切片赋值时传入的必须是可迭代对象
    except Exception as e:
        print(e)         # can only assign an iterable
    l[2:5] = (40,)
    print(l)             # [1, 2, 40, 7, 8, 9]
    l[2:3] = "sajfljls"  # 字符串属于序列,也可以迭代
    print(l)             # [1, 2, 's', 'a', 'j', 'f', 'l', 'j', 'l', 's', 7, 8, 9]

 

bisect

'''
    bisect模块主要用来管理有顺序的序列
    bisect模块包含的主要函数是bisect和insort,两个函数都使用二叉树方法搜索
    1、bisect(haystack, needle)
        haystack必须是一个有序的序列,该函数搜索needle在haystack中的位置,该位置使得将needle插入后haystack仍然升序
        查找到位置后可用haystack.insert()插入

    2、insort(seq, item)
        把item插入到seq中,并能保持seq的升序

'''

#  本人认为《流畅的python》中的对该模块介绍的例子比较经典,故引用之

# 1、关于bisect.bisect的示例
import bisect
import sys

HAYSTACK = [1, 4, 5, 6, 8, 12, 15, 20, 21, 23, 23, 26, 29, 30]
NEEDLES = [0, 1, 2, 5, 8, 10, 22, 23, 29, 30, 31]

ROW_FMT = '{0:2d} @ {1:2d}    {2}{0:<2d}'

def demo(bisect_fn):
    for needle in reversed(NEEDLES):
        position = bisect_fn(HAYSTACK, needle)
        offset = position * '  |'
        print(ROW_FMT.format(needle, position, offset))


if __name__ == '__main__':

    if sys.argv[-1] == 'left':
        bisect_fn = bisect.bisect_left
    else:
        bisect_fn = bisect.bisect

    print('DEMO:', bisect_fn.__name__)
    print('haystack ->', ' '.join('%2d' % n for n in HAYSTACK))
    demo(bisect_fn)


    '''   输出如下
    DEMO: bisect
    haystack ->  1  4  5  6  8 12 15 20 21 23 23 26 29 30
    31 @ 14      |  |  |  |  |  |  |  |  |  |  |  |  |  |31
    30 @ 14      |  |  |  |  |  |  |  |  |  |  |  |  |  |30
    29 @ 13      |  |  |  |  |  |  |  |  |  |  |  |  |29
    23 @ 11      |  |  |  |  |  |  |  |  |  |  |23
    22 @  9      |  |  |  |  |  |  |  |  |22
    10 @  5      |  |  |  |  |10
     8 @  5      |  |  |  |  |8 
     5 @  3      |  |  |5 
     2 @  1      |2 
     1 @  1      |1 
     0 @  0    0 
    '''
# 另,bisect.bisect函数有两个可选参数——lo和hi来缩小搜索范围,lo的默认值是0,hi的默认值是序列的长度
# 再另,bisect.bisect函数其实是bisect_right函数的别名,还有一个bisect_left,插入位置如果有相等的元素时,插入元素会放在它相等的
#      元素后面,后者会放在前面


# 根据分数,查到等级

def grade(score, breakpoints=[60, 70, 80, 90], grades = 'FDCBA'):
    i = bisect.bisect(breakpoints, score)     # 这里的bisect.bisect实际上使用的是bisect_right
    return grades[i]

print([grade(score) for score in [33, 55, 90, 87, 65, 78, 34, 60, 100]])

# 2、关于bisect.insort函数

import bisect
import random

SIZE = 7

random.seed(1729)

my_list = []
for i in range(SIZE):
    new_item = random.randrange(SIZE*2)
    bisect.insort(my_list, new_item)
    print('%2d ->' % new_item, my_list)

    '''输出:
    10 -> [10]
     0 -> [0, 10]
     6 -> [0, 6, 10]
     8 -> [0, 6, 8, 10]
     7 -> [0, 6, 7, 8, 10]
     2 -> [0, 2, 6, 7, 8, 10]
    10 -> [0, 2, 6, 7, 8, 10, 10]
    '''

# 另,insort函数也有insort_left,背后使用的是bisect_left

 

排序(list.sort方法和sorted函数)

'''
    list.sort方法和sorted内置函数都有排序的功能,区别如下
        list.sort是就地排序列表,不会把原列表复制一份。该方法返回None,以提醒不会新建一个列表。
        sorted函数会新建一个列表作为返回值,这个函数可以接受任何可迭代对象,甚至包括不可变序列或生成器,最后返回的总是列表。

    list.sort和sorted都有两个参数:
        reverse:默认为False,设定为True以降序排列
        key:一个只有一个参数的函数,这个函数会作用于序列的每一个元素上,然后以该函数的结果作为关键字排序

'''

if __name__ == "__main__":
    # 1、list.sort就地排序,而sorted返回列表
    l = [x for x in range(10, 0, -1)]      # 初始化一个列表:[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
    print(id(l), l)    # l最初的地址:4536449800 [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
    l.sort()
    print(id(l), l)    # 排序后的地址:4536449800 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
                       # l前后的的地址没变,说明是就地排序


    l = [x for x in range(10, 0, -1)]  # 初始化一个列表:[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
    print(id(l), l)  # l最初的地址:4415318984 [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
    l = sorted(l)
    print(id(l), l)  # 排序后的地址:4415318792 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    # 2、sorted可以接受任何可迭代对象
    l = (x for x in range(10, 0, -1))
    print(type(l))        # 迭代器 <class 'generator'>
    print(sorted(l))      # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    s = "qwertyuiopasdfghjklzxcvbnm"   # 字符串序列
    print(sorted(s))      # ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

    s = (1, 3, 2, 456, 345, 12, 2, 5, 78, 34)   # 不可变元组
    print(sorted(s))      # [1, 2, 2, 3, 5, 12, 34, 78, 345, 456]

    # 3、reverse参数
    s = "qwertyuiopasdfghjklzxcvbnm"
    print(sorted(s, reverse=True))   # ['z', 'y', 'x', 'w', 'v', 'u', 't', 's', 'r', 'q', 'p', 'o', 'n', 'm', 'l', 'k', 'j', 'i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']


    # 4、key参数
    s = "QwERTYuioPaSdfGHjKLzXcvbnm"
    print(sorted(s))    # ['E', 'G', 'H', 'K', 'L', 'P', 'Q', 'R', 'S', 'T', 'X', 'Y', 'a', 'b', 'c', 'd', 'f', 'i', 'j', 'm', 'n', 'o', 'u', 'v', 'w', 'z']
    print(sorted(s, key=str.lower))   # 忽略大小写 ['a', 'b', 'c', 'd', 'E', 'f', 'G', 'H', 'i', 'j', 'K', 'L', 'm', 'n', 'o', 'P', 'Q', 'R', 'S', 'T', 'u', 'v', 'w', 'X', 'Y', 'z']
    print(sorted(s, key=str.upper))   # 也是忽略大小写

##########################
#
#  以下自定义一个类也可使用sorted函数
#
##########################

class Obj:
    def __init__(self):
        self.s = [x for x in range(10, 0, -1)]

    def __getitem__(self, item):
        print("getitem")
        return self.s[item]

    def __repr__(self):
        return str(self.s)

    def __iter__(self):
        return iter(self.s)

obj = Obj()
print(obj)           # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

# 添加getitem后可以使用sorted函数  (实验时请注视掉getitem方法)
print(sorted(obj))   #  打印10次getitem   , [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 添加iter方法
print(sorted(obj))   # 此时解释器会先调用iter方法,不会再使用getitem方法
                     # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

使自定义类也可使用sorted函数调用

 

python高等连串小说目录

python高级——目录

 

 

bisect

'''
    bisect模块主要用来管理有顺序的序列
    bisect模块包含的主要函数是bisect和insort,两个函数都使用二叉树方法搜索
    1、bisect(haystack, needle)
        haystack必须是一个有序的序列,该函数搜索needle在haystack中的位置,该位置使得将needle插入后haystack仍然升序
        查找到位置后可用haystack.insert()插入

    2、insort(seq, item)
        把item插入到seq中,并能保持seq的升序

'''

#  本人认为《流畅的python》中的对该模块介绍的例子比较经典,故引用之

# 1、关于bisect.bisect的示例
import bisect
import sys

HAYSTACK = [1, 4, 5, 6, 8, 12, 15, 20, 21, 23, 23, 26, 29, 30]
NEEDLES = [0, 1, 2, 5, 8, 10, 22, 23, 29, 30, 31]

ROW_FMT = '{0:2d} @ {1:2d}    {2}{0:<2d}'

def demo(bisect_fn):
    for needle in reversed(NEEDLES):
        position = bisect_fn(HAYSTACK, needle)
        offset = position * '  |'
        print(ROW_FMT.format(needle, position, offset))


if __name__ == '__main__':

    if sys.argv[-1] == 'left':
        bisect_fn = bisect.bisect_left
    else:
        bisect_fn = bisect.bisect

    print('DEMO:', bisect_fn.__name__)
    print('haystack ->', ' '.join('%2d' % n for n in HAYSTACK))
    demo(bisect_fn)


    '''   输出如下
    DEMO: bisect
    haystack ->  1  4  5  6  8 12 15 20 21 23 23 26 29 30
    31 @ 14      |  |  |  |  |  |  |  |  |  |  |  |  |  |31
    30 @ 14      |  |  |  |  |  |  |  |  |  |  |  |  |  |30
    29 @ 13      |  |  |  |  |  |  |  |  |  |  |  |  |29
    23 @ 11      |  |  |  |  |  |  |  |  |  |  |23
    22 @  9      |  |  |  |  |  |  |  |  |22
    10 @  5      |  |  |  |  |10
     8 @  5      |  |  |  |  |8 
     5 @  3      |  |  |5 
     2 @  1      |2 
     1 @  1      |1 
     0 @  0    0 
    '''
# 另,bisect.bisect函数有两个可选参数——lo和hi来缩小搜索范围,lo的默认值是0,hi的默认值是序列的长度
# 再另,bisect.bisect函数其实是bisect_right函数的别名,还有一个bisect_left,插入位置如果有相等的元素时,插入元素会放在它相等的
#      元素后面,后者会放在前面


# 根据分数,查到等级

def grade(score, breakpoints=[60, 70, 80, 90], grades = 'FDCBA'):
    i = bisect.bisect(breakpoints, score)     # 这里的bisect.bisect实际上使用的是bisect_right
    return grades[i]

print([grade(score) for score in [33, 55, 90, 87, 65, 78, 34, 60, 100]])

# 2、关于bisect.insort函数

import bisect
import random

SIZE = 7

random.seed(1729)

my_list = []
for i in range(SIZE):
    new_item = random.randrange(SIZE*2)
    bisect.insort(my_list, new_item)
    print('%2d ->' % new_item, my_list)

    '''输出:
    10 -> [10]
     0 -> [0, 10]
     6 -> [0, 6, 10]
     8 -> [0, 6, 8, 10]
     7 -> [0, 6, 7, 8, 10]
     2 -> [0, 2, 6, 7, 8, 10]
    10 -> [0, 2, 6, 7, 8, 10, 10]
    '''

# 另,insort函数也有insort_left,背后使用的是bisect_left

python内置系列类型,python内置种类类型 本文主要内容 系列类型分类:
(一)容器连串、扁平连串 (2)可变系列、不可…


相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图