range

range(start, stop[, step])

  • start: 计数从 start 开始。默认是从 0 开始。例如range(5)等价于range(0, 5)

  • stop: 计数到 stop 结束,但不包括 stop。例如:range(0, 5) 是[0, 1, 2, 3, 4]没有5

  • step:步长,默认为1。例如:range(0, 5) 等价于 range(0, 5, 1)

range实例: 冒泡排序

list1 = [3, 4, 54, 231, 55, 223, 5412, 1, 2]


def maopao(array):
    for i in range(1, len(list1)):  # 列表长度为9只需要走8轮排序就可以
        print("当前是第{}轮冒泡排序".format(i))
        for j in range(0, len(list1) - i):
            print("当前索引位置在第{}个位置".format(j))
            if array[j] > array[j + 1]:
                array[j], array[j + 1] = array[j + 1], array[j]
    return array


print(maopao(list1))

输出:

当前是第1轮冒泡排序
当前索引位置在第0个位置
当前索引位置在第1个位置
当前索引位置在第2个位置
当前索引位置在第3个位置
当前索引位置在第4个位置
当前索引位置在第5个位置
当前索引位置在第6个位置
当前索引位置在第7个位置  # 当索引位置在7时,已经完成了找到最大值,并且把最大值放在了列表的最后
当前是第2轮冒泡排序
当前索引位置在第0个位置
当前索引位置在第1个位置
当前索引位置在第2个位置
当前索引位置在第3个位置
当前索引位置在第4个位置
当前索引位置在第5个位置
当前索引位置在第6个位置  # 当下一次继续索引时就可以不用比较列表最后一个值了,依次类推
当前是第3轮冒泡排序
当前索引位置在第0个位置
当前索引位置在第1个位置
当前索引位置在第2个位置
当前索引位置在第3个位置
当前索引位置在第4个位置
当前索引位置在第5个位置
当前是第4轮冒泡排序
当前索引位置在第0个位置
当前索引位置在第1个位置
当前索引位置在第2个位置
当前索引位置在第3个位置
当前索引位置在第4个位置
当前是第5轮冒泡排序
当前索引位置在第0个位置
当前索引位置在第1个位置
当前索引位置在第2个位置
当前索引位置在第3个位置
当前是第6轮冒泡排序
当前索引位置在第0个位置
当前索引位置在第1个位置
当前索引位置在第2个位置
当前是第7轮冒泡排序
当前索引位置在第0个位置
当前索引位置在第1个位置
当前是第8轮冒泡排序
当前索引位置在第0个位置
[1, 2, 3, 4, 54, 55, 223, 231, 5412]

repr(object)

返回对象的可打印形式字符串。

print(repr((1, 2)))  # 元组
print(type(repr((1, 2))))

print(repr([1, 2]))  # 列表
print(type(repr([1, 2])))

print(repr({1: 2, 'name': 5}))  # 字典
print(type(repr({1: 2, 'name': 5})))

print(repr('?'))  # 字符串,注意与ascii()函数区别
print(type(repr("?")))

print(repr(set([1, 1, 2, 3])))  # 集合,由set()创建
print(type(repr(set([1, 1, 2, 3]))))


输出: 均为字符串类型

(1, 2)
<class 'str'>
[1, 2]
<class 'str'>
{1: 2, 'name': 5}
<class 'str'>
'?'
<class 'str'>
{1, 2, 3}
<class 'str'>

reversed()

有些时候,程序需要进行反向遍历,此时可通过 reversed() 函数,该函数可接收各种序列(元组、列表、区间等)参数,然后返回一个“反序排列”的法代器,该函数对参数本身不会产生任何影响。

a = range(10)
print([x for x in reversed(a)])
print(a)
输出:
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
range(0, 10)

reversed也可对字符串列表等进行反转

round()

使用方法:round(number,digits)

  • digits>0,四舍五入到指定的小数位
  • digits=0, 四舍五入到最接近的整数
  • digits<0 ,在小数点左侧进行四舍五入
  • 如果round()函数只有number这个参数,等同于digits=0

round使用保留可能有坑,如果需要很精确的值,请查明使用


set()

set()函数创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等。

创建集合:
x = set([1, 2, 3])
print(x, type(x))

输出:
{1, 2, 3} <class 'set'>

添加:
a = set()
a.add("i")
a.add("love")
a.add("python")
print(a)

输出:
{'i', 'python', 'love'}

拆分新增:
a = set()
a.update("love")
print(a)

输出:
{'l', 'e', 'o', 'v'}

删除元素:

a = set("love")
print(a)
a.remove("e")
print(a)

输出:
{'e', 'o', 'l', 'v'}
{'o', 'l', 'v'}

s1 = set('here')
s2 = set('hello')
print(s1-s2)#差集
print(s1&s2)#交集
print(s1|s2)#并集

slice()

slice(start, stop[, step]) 函数实现切片对象,主要用在切片操作函数里的参数传递。返回一个切片对象。

a = ("a", "b", "c", "d", "e", "f", "g", "h")
x = slice(2)
print(a[x])

输出:
('a', 'b')

sorted()

sort 与 sorted 区别:

sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作,无返回值,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。

list1 = [1, 4, 2, 55, 43, 278, 213, 555, 99]
print(sorted(list1))
print(sorted(list1, reverse=True))

输出:
[1, 2, 4, 43, 55, 99, 213, 278, 555]
[555, 278, 213, 99, 55, 43, 4, 2, 1]

sum()

sum(iterable, /, start=0) 需要适用可迭代对象

print(sum([1, 2, 3], 5))  # in list +start

print(sum((1, 2, 3)))  # in tuple

print(sum({1, 2, 3}))  # in set

print(sum({1: 5, 2: 6, 3: 7}))  # in dictionary key

print(sum(range(1, 4)))  # in range()

输出:
11
6
6
6
6

super()

super函数简介

通常情况下,我们在子类中定义了和父类同名的方法,那么子类的方法就会覆盖父类的方法。而super关键字实现了对父类方法的改写(增加了功能,增加的功能写在子类中,父类方法中原来的功能得以保留)。也可以说,super关键字帮助我们实现了在子类中调用父类的方法

super()的主要用法有两种: 在单类继承中,其意义就是不需要父类的名称来调用父类的函数,因此当子类改为继承其他父类的时候,不需要对子类内部的父类调用函数做任何修改就能调用新父类的方法。 比如:

class FooA:
    def __init__(self, msg):
        self.msg = msg
        print(self.msg)
        self.num = 1
        self.suanfa = "cheng"

    def add(self, a, b):
        print(a + b)


class FooB(FooA):
    def __init__(self, msg):
        super().__init__(msg)
        self.num = 2
        self.suanfa = "add"

    def add(self, a, b):
        print(a * b)


class FooC(FooA):
    pass


f = FooB("你好")
f.add(2, 3)
print(f.num)
print(f.suanfa)
print(f.date)
print("-" * 50)
t = FooC("不错")
t.add(2, 3)
print(t.num)
print(t.suanfa)

输出:
你好
6
2
add
2021-11-22
--------------------------------------------------
不错
5
1
cheng

解析:
FooB重写了父类FooA的方法,并新增了init的属性值,但是没有改动父类的值
FooC集成了父类FooA的方法验证了上面说的这点
但是实际上在集成中我们之所以用super还有另一点为了防止多次初始化,见下面的栗子:

      Base
      /  \
     /    \
    A      B   # 继承方式下
     \    /
      \  /
       C


class Base:
    def __init__(self):
        print('Base.__init__')


class A(Base):
    def __init__(self):
        Base.__init__(self)
        print('A.__init__')


class B(Base):
    def __init__(self):
        Base.__init__(self)
        print('B.__init__')


class C(A, B):
    def __init__(self):
        A.__init__(self)
        B.__init__(self)
        print('C.__init__')

C()

结果输出:
Base.__init__
A.__init__
Base.__init__
B.__init__
C.__init__

那么Base.__init__初始化两次肯定不是我们想要的结果,那么就有了super

class Base:
    def __init__(self):
        print('Base.__init__')


class A(Base):
    def __init__(self):
        super().__init__()
        print('A.__init__')


class B(Base):
    def __init__(self):
        super().__init__()
        print('B.__init__')


class C(A, B):
    def __init__(self):
        super().__init__()
        print('C.__init__')

同样执行C()

输出:
Base.__init__
B.__init__
A.__init__
C.__init__

至于为什么排序显示是这样的,那是因为我们每定义一个类的时候,Python都会创建一个MRO列表,用来管理类的继承顺序。

type()

查看数据类型

list1 = [x for x in range(3)]
str1 = "hello"
tuple1 = (1,)
dict1 = dict(a="你好", b="hello")

print(type(list1))
print(type(str1))
print(type(tuple1))
print(type(dict1))

输出:
<class 'list'>
<class 'str'>
<class 'tuple'>
<class 'dict'>

zip()

它可以将多个序列(列表、元组、字典、集合、字符串以及 range() 区间构成的列表)“压缩”成一个 zip 对象。所谓“压缩”,其实就是将这些序列中对应位置的元素重新组合,生成一个个新的元组。

语法格式:zip(iterable, ...) 其中 iterable,... 表示多个列表、元组、字典、集合、字符串,甚至还可以为 range() 区间。

my_list = [11, 12, 13]
my_tuple = (21, 22, 23)

print([x for x in zip(my_list, my_tuple)])

my_dic = {31: 2, 32: 4, 33: 5}
my_set = {41, 42, 43, 44}

print([x for x in zip(my_dic, my_set)])

my_pychar = "python"
my_shechar = "shell"

print([x for x in zip(my_pychar, my_shechar)])

输出:
[(11, 21), (12, 22), (13, 23)]
[(31, 41), (32, 42), (33, 43)]  # 字典部分取key
[('p', 's'), ('y', 'h'), ('t', 'e'), ('h', 'l'), ('o', 'l')]
# 在使用 zip() 函数“压缩”多个序列时,它会分别取各序列中第 1 个元素、第 2 个元素、... 第 n 个元素,各自组成新的元组。需要注意的是,当多个序列中元素个数不一致时,会以最短的序列为准进行压缩。


# 解压缩
a = [(11, 21), (12, 22), (13, 23)]

print([x for x in zip(*a)])

x1, x2 = zip(*a)
print(x1, x2)

输出:
[(11, 12, 13), (21, 22, 23)]
(11, 12, 13) (21, 22, 23)

__import__

操作系统中允许文件名中包含空格,也就是说,模块文件可以起名为类似“a b”的形式。但这和 Python 语法相矛盾,换句话说,Python 是以空格来隔离一行语句中的不同元素的,如果模块名中出现空格,就无法再使用 import 引入。

我们自定义一个模块,并起名为 "test demo.py",该模块中只包含如下输出语句:
print("hahah")
我们再定义一个模块,起名为"1demo.py",该模块中只包含如下输出语句:
print("heiheihei")

当我们用常规模式去导入时:
import test demo

    import test demo
                ^
SyntaxError: invalid syntax

1demo同理,那么无法import怎么办呢?

使用__import__
__import__("test demo")
__import__("1demo")

输出:
hahah
heiheihei


注意,使用 __import__() 函数引入模块名时,要以字符串的方式将模块名引入,否则会报 SyntaxError 错误。