[Python]进阶

列表和元组

python内置了许多种序列, 如列表, 元组, 字符串. 他们有许多相似的操作也有各自的特殊性质.

Python支持一种数据结构的基本概念，名为容器（container）。容器基本上就是可包含其他对象的对象。两种主要的容器是序列（如列表和元组）和映射（如字典）。在序列中，每个元素都有编号，而在映射中，每个元素都有名称（也叫键）。

有几种操作适用于所有序列，包括索引、切片、相加、相乘、迭代和成员资格检查

通用序列操作

索引

# -*- coding: utf-8 -*-

# eg1 索引
months = [
    'Jan',
    'Feb',
    'Mar',
    'Apr',
    'May',
    'Jun',
    'Jul',
    'Aug',
    'Sep',
    'Oct',
    'Nov',
    'Dec'
]

endings = ['st', 'nd', 'rd'] \
    + 17 * ['th'] + ['st', 'nd', 'rd'] \
    + 7 * ['th'] + ['st']

year = input("Year: ")
month = input("Month: ")
day = input("Day: ")

month_num = int(month) - 1
day_num = int(day) - 1

print("==========================")
print(months[month_num] + " " + day + endings[day_num] + ", " + year)

切片E

t = (0, 1, 2, 3, 4, 5, 6)
print(t[::-1])
print(t[-1:-3:])
print(t[-3:-1])
print(t[-1:-3:-1])
# 左闭右开
'''
(6, 5, 4, 3, 2, 1, 0)
()
(4, 5)
(6, 5)
'''

相加&乘法

str1 = "foo"
str2 = "bar"
print(str1 + str2)
tup1 = (1, 2)
tup2 = (3, 4)
print(tup1 + tup2)
'''
foobar
(1, 2, 3, 4)
'''

print(str1*10)
print(tup1*10)
'''
foofoofoofoofoofoofoofoofoofoo
(1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2)
'''

ls = [None]
print(ls*4)
# [None, None, None, None]

# -*- coding: utf-8 -*-
import os
screen_width = os.get_terminal_size().columns

sentence = input("Sentence:\n==>")
padding = 3
box_width = len(sentence) + (padding+1)*2
margin_left = (screen_width-box_width) >> 1

print()
print(" "*margin_left + "*" + "-"*(box_width-2) + "*")
print(" "*margin_left + "|" + " "*(box_width-2) + "|")
print(" "*margin_left + "|" + " "*padding + sentence + " "*padding + "|")
print(" "*margin_left + "|" + " "*(box_width-2) + "|")
print(" "*margin_left + "*" + "-"*(box_width-2) + "*")

成员资格

# -*- coding: utf-8 -*-

str = "I wanna get rich, ^=^"
print("$" in str)
print("&" in str)

db = [
      ["slacr", "11111"],
      ["smith", "12345"],
      ["frank", "33331"],
      ]

username = input("login:")
password = input("passwd:")

if [username, password] in db:
    print("Access granted")
else:
    print("Access denyed")

列表

# -*- coding: utf-8 -*-

ls = [1, 2, 3, 4, 5, 5, 5]
del ls[4]
print(ls)
del ls[-2:]
print(ls)

ls[0] = "test"
print(ls)

ls = list("good")
print(ls)

s = "".join(ls)
print(s)


# 替换一个空切片, 相当于插入
ls[2:2] = "hi"
print(ls)

del ls[2 : 4]
print(ls)

ls2 = [1, "-", 2, "-", 3]
del ls2[1:-1:2]
print(ls2)

# -*- coding: utf-8 -*-

ls = [1, 3, 2, 5, 4]
ls_copy = ls.copy()
ls.sort()
print(ls)
# sort方法返回None, 修改原序列

res = sorted(ls_copy)
print(res)
print(ls_copy)
# sorted() 返回新序列, 不该变原序列

# -*- coding: utf-8 -*-

# 高级排序
x = [1, 3, 4, 5, 2]
x.sort(reverse=True)
print(x)

s = ["dfsd", "sd", "是非得失发", "dsfdsfdsfdsfsdfsdf"]
s.sort(key=len)
# 像C++中的比较器, 每次迭代器获得的值先传给len()函数处理再比较排序
print(s)

ls = [1, 3, 2, 5, 4, 2, 4, 2, 1, 1, 1, 1]
print(max(set(ls), key=ls.count))

元组

与列表一样，元组也是序列，唯一的差别在于元组是不能修改的

# -*- coding: utf-8 -*-

t = 2,3,4
print(t)


# 长度为1的元组
t = 2,
print(t)

print(3 * (1,'#'))

print(list((2,3)))
print(tuple([2,3]))
print(tuple("23"))
print(list("23"))

字符串

设置格式

way 1

# -*- coding: utf-8 -*-

# 设置字符串
print("%s, %.2f, %-5d, %x, %o"%("hi", 12.2345, 11, -11, 9))
# hi, 12.23, 11   , -b, 11

way 2

# -*- coding: utf-8 -*-

from string import Template
templ = Template("You are the \place")
s = templ.substitute(item = "shit", place = "hand")
print(s)
# You are the shit in my hand

way 3

# -*- coding: utf-8 -*-

from math import pi
print("{name} is approximately {value:.2f}".format(name = "pi", value = pi))

str = "slacr"
print(f"{str} will be somebody")
# python 3.6中, 变量与替换字段同名, 可以简写, 不用键值对, 相当于省略.format{str=str}

完整版

替换字段由如下部分组成，其中每个部分都是可选的。

字段名：索引或标识符，指出要设置哪个值的格式并使用结果来替换该字段。除指定值外，还可指定值的特定部分，如列表的元素。
转换标志：跟在叹号后面的单个字符。当前支持的字符包括r（表示repr）、s（表示str）和a（表示ascii）。如果你指定了转换标志，将不使用对象本身的格式设置机制，而是使用指定的函数将对象转换为字符串，再做进一步的格式设置。
格式说明符：跟在冒号后面的表达式（这种表达式是使用微型格式指定语言表示的）。格式说明符让我们能够详细地指定最终的格式，包括格式类型（如字符串、浮点数或十六进制数），字段宽度和数的精度，如何显示符号和千位分隔符，以及各种对齐和填充方式。

# -*- coding: utf-8 -*-

print("{a}{}{b}{}".format(2, 4, a = 1, b = 3)) # 1234

import math 
templ = "The {mod.__name__} modeule defines the value {mod.pi} for π"
res = templ.format(mod=math)
print(res)
# The math modeule defines the value 3.141592653589793 for π

s = "{temp[1]}".format(temp = "abc")
print(s)  #b

# -*- coding: utf-8 -*-


print("{num:b}".format(num = 42))
print("{num:c}".format(num = 0x6211))
print("{num:e}".format(num = 23.45))
print("{num:%}".format(num = 23.45))


print("{num!a}".format(num = "我"))
print("{num!s}".format(num = "我"))
print("{num!r}".format(num = "我"))

'''
101010
我
2.345000e+01
2345.000000%
'\u6211'
我
'我'
'''

# -*- coding: utf-8 -*-


print("One googol is {:,}".format(10**100))

print("{:010}".format(3.14))
print("{:+10}".format(3.14))
print("{:->10}".format(3.14))

print("{:$^12}".format("WIN"))
print("{:+=12}".format(-3.4))

#%%
print("{:b}".format(42))
print("{:#b}".format(42))
#%%

'''
One googol is 10,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000
0000003.14
     +3.14
------3.14
MATHJAX-SSR-58
-++++++++3.4
101010
0b101010
'''

# -*- coding: utf-8 -*-

width = int(input('Please enter width: ')) 
price_width = 10 
item_width = width - price_width 
header_fmt = '{{:{}}}{{:>{}}}'.format(item_width, price_width) 
fmt =        '{{:{}}}{{:>{}.2f}}'.format(item_width, price_width) 
# 双大括号用于转义

print('=' * width) 
print(header_fmt.format('Item', 'Price')) 
print('-' * width) 
print(fmt.format('Apples', 0.4)) 
print(fmt.format('Pears', 0.5)) 
print(fmt.format('Cantaloupes', 1.92)) 
print(fmt.format('Dried Apricots (16 oz.)', 8)) 
print(fmt.format('Prunes (4 lbs.)', 12)) 
print('=' * width)

字符串方法

# -*- coding: utf-8 -*-

dirs = 'usr', 'bin', 'env'
print('/'.join(dirs))
# join操作的序列必须是字符串

print("ASdsfd是".lower())


# 词首大写
print("that's all folks".title())
import string
print(string.capwords("that's all folks"))

# 分隔, 默认是空白符 
print("/usr/bin/env".split('/'))
print("what the fuck".split())

# 裁剪
print("###good###".strip('#'))

# 替换 
print("aaaabbb".replace('a', 'b'))

# 转换
table = str.maketrans("abc", "123")
print(table)
# 建立字符的转换表
print("abcabc".translate(table))

print(ascii("电视"))
print("Good".istitle())
print("test".capitalize())

字典

items = [("name", "slacr"), ("age", "19")]
print(dict(items)["name"])

d = dict(name = "slacr", age = 19)
print(d["age"])

x = {}
x[1] = "a"
x[2] = "b"
print(x)

# -*- coding: utf-8 -*-

numlist = {
    "slacr":{
        "country":"china",
        "age": 19
        },
    "muphy":{
        "country":"england",
        "age":23
        },
    "sakura":{
        "country":"japan",
        "age":34
        }
    }

fmt = {
       "country": "country",
       "age": "age"
       }

name = input("Name:")
request = input("Country(c) or Age(a)?")

if request == 'c' : key = 'country'
if request == 'a' : key = 'age'

if name in numlist : print("{}'s {} is {}.".format(name, fmt[key], numlist[name][key]))

字符串设置功能用于字典

# -*- coding: utf-8 -*-

phonebook = {"slacr":"1234", "brain":"2341", "vector":"9990"}
print("slacr's phone number is {slacr}".format_map(phonebook))

字典方法

# -*- coding: utf-8 -*-

print({}.fromkeys(["name", "age"]))
print(dict.fromkeys(["name", "age"], 'undefined'))

# %%

d = {}
print(d.get("name"))
# 使用get()方法如果没有此key将返回None ,而使用索引则会抛出keyError异常

# %%

d = {'x': 1, 'y': 2}
d.pop('x')
print(d)
print(d.popitem())

# %%

d = {}
d.setdefault("name", "unknown")
print(d)

d = {}
d.setdefault("name")
print(d)
# 没指定默认值None

# %%

d = {
    "title": 'Python Web Site',
    'url': "http://www.python.org",
    'changed': "June 3 22:13:10"
}
x = {"title": "Python Language Website"}
d.update(x)
print(d)
# 使用一个字典来更新另一个字典

# %%

d = {"name": "Donald Trump", "age": 82}
print(d.keys())
print(d.values())
# 返回对应的列表视图

# %%
print("123", "456", "78", sep="", end="9")

条件循环

导包

# -*- coding: utf-8 -*-

import somemodule 
from somemodule import somefunction 
from somemodule import somefunction, anotherfunction, yetanotherfunction 
from somemodule import *

# %%
import math as foobar
from math import sqrt as foobar
# as 添加别名, 可以用来区别不同包中的同名函数

赋值魔法

# -*- coding: utf-8 -*-

# 序列解包
x, y = 1, 2
x, y = y, x
print(x, y)

d = {"name": "jack", "gfriend": "rose"}
key, value = d.popitem()
print(key, value)

a, b, *rest = [1, 2, 3 ,4 ]
print(rest)
# 正常解包必须左右数目相同, 否则ValueError, *号能收集多余的值成为一个列表

# %%

# 链式赋值
x = y = 1

布尔值

# -*- coding: utf-8 -*-
print(bool(None))
print(bool(0))
print(True == 1)
print(1 < 2 < 3)

# -*- coding: utf-8 -*-

x = [1, 2, 3]
y = z = [1, 2]
print(y is z)
print(y == z)

print(x is not y)
del x[-1]
print(x == y)
print(x is y)

# is 判断是否为同一个对象

# %%

# 非数值的比较会比较ord()值
print(ord("我"))
print(chr(ord("我")))
print(ascii("我"))

'''
25105
我
'\u6211'
'''

断言

# -*- coding: utf-8 -*-

# 断言
age = -1
assert 0 < age <= 100, "The age must be realistic"

一些迭代

# -*- coding: utf-8 -*-

names = ['anne', 'beth', 'george', 'damon']
ages = [12, 45, 32, 102]

for i in range(len(names)):
    print(names[i], " is ", ages[i], "years old")
# 并行迭代, range默认生成序列从0开始

# %%

for name, age in zip(names, ages):  # 将序列缝合成多元组序列, 不等长时会取较短的
    print(name, " is ", age, "years old")

# %% 迭代时获取索引

strings = ['a', 'b', 'c', '#']
for index, string in enumerate(strings):
    if string == '#':
        del strings[index]
print(strings)

# %% 反向迭代和排序后迭代
print(sorted((1, 3, 4, 2, 5)))

r = reversed("slacr")
print(r)
l = list(r)
print(l)
print("".join(l))
# sorted返回一个列表，而reversed像zip那样返回一个可迭代对象。

循环中的 else

# -*- coding: utf-8 -*-

from math import sqrt
for n in range(99, 80, -1):
    root = sqrt(n)
    if root == int(root):
        print(n)
        break
else:
    print("Didn't find it!")

# 可以看到 添加了 else的循环语句, else部分与这个循环属于一个整体, 如果
# 循环中出现break, 那么会调出循环(不执行else), 而没出现break, else必执行
# 故else 可以用来判断一个循环是否出现了break, 是否正常执行结束

简单推导

列表推导是一种从其他列表创建列表的方式，类似于数学中的集合推导。列表推导的工作原理非常简单，有点类似于for循环。

# -*- coding: utf-8 -*-

ls = [x*x for x in range(10, 0, -1)]
print(ls)

ls = [(x, y) for x in range(3) for y in range(3)]
print(ls)


# %%
girls = ['alice', 'bernice', 'clarice']
boys = ['chris', 'arnold', 'bob']
ls = [(b, g) for b in boys for g in girls if b[0] == g[0]]
print(ls)

# 更高效的方法
girls.append("angella")
letterGirls = {}
for girl in girls:
    letterGirls.setdefault(girl[0], []).append(girl)
# 一对多的字典
print([(b, g) for b in boys for g in letterGirls[b[0]]])


# %%

# 字典推导
squares = {i:"{} squared is {}".format(i, i**2) for i in range(10)}
print(squares[7])
import string
capital = {a: "{} capitalizes is {}".format(a, a.capitalize()) for a in string.ascii_lowercase}
print(capital['r'])

pass del exec

# -*- coding: utf-8 -*-

name = ""
if name == "slacr":
    print("please in")
elif name.find("slacr") != -1:
    # ...
    # python 中代码块 不能为空, 修复这个问题, 只需添加一条pass 语句
    pass
else:
    print("fatal")

# %%
# 对于你不再使用的对象，Python通常会将其删除（因为没有任何变量或数据结构成员指向它）, GC
# 另一种方法是使用 del 函数

x = 1
del x

ls = ["good", "job"]
ls2 = ls
del ls2
print(ls)
# del 只会删除引用

# %%
exec("print('Hi~ o(*￣▽￣*)ブ')")
# 然而，调用函数exec时只给它提供一个参数绝非好事。在大多数情况下，还应向它传递一个命名空间——用于放置变量的地方；

from math import sqrt
# exec("sqrt = 1")
# sqrt(4)
# 污染了原命名空间

# %%

from math import sqrt
# 添加命名空间
scope = {}
exec("sqrt = 1", scope)
print(len(scope))
print(scope["sqrt"])
print(sqrt(4))

# %%
# 一个python 计算器
print(eval(input("Enter an arithmetic expression:")))
# 这也是不安全的, 传入了不可信任的代码, 可以注入脚本

# %%
scope = {}
scope['x'] = 1
scope['y'] = 2
print(eval('x*y',scope))

因此，将eval用于不可信任的代码并不比使用exec安全。当前，在Python中执行不可信任的代码时，没有安全的办法。一种替代解决方案是使用Jython等Python实现，以使用Java沙箱等原生机制。

抽象

自定义函数

# -*- coding: utf-8 -*-

import math 
x = 1
y = math.sqrt
print(callable(x), callable(y))
# 判断某个对象是否可调用

给函数写文档

要给函数编写文档，以确保其他人能够理解，可添加注释（以#打头的内容）。还有另一种编写注释的方式，就是添加独立的字符串。在有些地方，如def语句后面（以及模块和类的开头，），添加这样的字符串很有用。放在函数开头的字符串称为文档字符串（docstring），将作为函数的一部分存储起来。

# -*- coding: utf-8 -*-

def square(x):
    'Calculates the square of the number x.'
    return x*x

print(square.__doc__)
help(square)

特殊的内置函数help很有用。在交互式解释器中，可使用它获取有关函数的信息，其中包含函数的文档字符串。

所有的函数都返回值。如果你没有告诉它们该返回什么，将返回None。

收集参数

# -*- coding: utf-8 -*-

def print_params(title, *params):
    print(title)
    print(params)

print_params("Params:", 1, 2, 3)
'''
Params:
(1, 2, 3)
'''

# %%

# 收集参数可以不放在最后, 但需要使用名称来制定后续参数
def in_the_middle(x, *y, z):
    print(x, y, z)
in_the_middle(1, 2,3, 4, 5, z=6)

# %%

def print_key_params(**params):
    print(params)

print_key_params(a = 1, b = 2, sth = "good")

#收集关键字参数要用两个 '*'

分配参数

# -*- coding: utf-8 -*-

def add(x,y) :
    return x+y

params = (1, 2)
print(add(*params))

# %%

# 如果在定义和调用函数时都使用*或**，将只传递元组或字典。因此还不如不使用它们，还
# 可省却些麻烦。
def with_stars(**kwds): 
    print(kwds['name'], 'is', kwds['age'], 'years old') 

def without_stars(kwds): 
    print(kwds['name'], 'is', kwds['age'], 'years old')

args = {'name': 'Mr. Gumby', 'age': 42}
with_stars(**args)
without_stars(args)

# 这两种做法的效果相同。因此，只有在定义函数（允
# 许可变数量的参数）或调用函数时（拆分字典或序列）使用，星号才能发挥作用。

作用域


x, y = 1, 2
scope = vars()
# 返回当前作用域的字典
print(scope["scope"]["scope"]["x"])

# print(dir())

# 一般而言，不应修改vars返回的字典，因为根据Python官方文档的说法，这样做的结果是不确定的。

# %%
def combine(parameter):
    print(parameter + globals()['parameter'])
    print(locals())
parameter = "berry"
combine("Shrub")

# globals(), locals() 分别返回全局/ 局部 变量的字典

# %% 
x = 1
def change_global():
    global x
    x = x + 1

change_global()
print(x)

# %%

作用域嵌套

def multiplier(factor):
    def multiplyByFactor(number):
        return number * factor
    return multiplyByFactor

double = multiplier(2)
triple = multiplier(3)

print(double(3), triple(3))

print(multiplier(3)(5))

#像multiplyByFactor这样存储其所在作用域的函数称为闭包。

通常，不能给外部作用域内的变量赋值，但如果一定要这样做，可使用关键字nonlocal。这个关键字的用法与global很像，让你能够给外部作用域（非全局作用域）内的变量赋值。

def multiplier(factor):
    factor = 1
    def multiplyByFactor(number):
        nonlocal factor
        factor = 10
        return number * factor
    return multiplyByFactor


print(multiplier(3)(5))

函数式编程

Python提供了一些有助于进行这种函数式编程的函数：map、filter和reduce。在较新的Python版本中，函数map和filter的用途并不大，应该使用列表推导来替代它们。


print(list(map(str, range(10))))

# 与[str(i) for i in range(10)]等价

seq = ["foo", "x41", "?!", "***"]
print(list(filter(str.isalnum, seq)))

#  [x for x in seq if x.isalnum()]


numbers = [72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33] 
from functools import reduce 
print(reduce(lambda x, y: x + y, numbers))

面向对象

自定义类


class Person:
    def set_name(self, name):
        self.name = name
    def get_name(self):
        return self.name
    def greet(self):
        print("Hello, world! I'm {}".format(self.name))
        
foo = Person()
foo.set_name("slacr")
foo.greet()

Python没有为私有属性提供直接的支持，而是要求程序员知道在什么情况下从外部修改属性是安全的。毕竟，你必须在知道如何使用对象之后才能使用它。然而，通过玩点小花招，可获得类似于私有属性的效果。
要让方法或属性成为私有的（不能从外部访问），只需让其名称以两个下划线打头即可。


class Person:
    money = 100.3
    __money = 100.4

    def set_name(self, name):
        self.name = name

    def get_name(self):
        return self.name

    def greet(self):
        print("Hello, world! I'm {}".format(self.name))


foo = Person()
foo.set_name("slacr")

print(foo.money)
# print(foo.__money)

# %%


class Secretive:
    def __inaccessible(self):
        print("Bet you can't see me ...")

    def accessible(self):
        print("The secret message is:")
        self.__inaccessible()

# 现在从外部不能访问__inaccessible，但在类中（如accessible中）依然可以使用它。


s = Secretive()
# %%
# 在类定义中，对所有以两个下划线打头的名称都进行转换，即在开头加上一个下划线和类名。
print(Secretive()._Secretive__inaccessible)

s._Secretive__inaccessible()
# 只要知道这种幕后处理手法，就能从类外访问私有方法，然而不应这样做。

# 如果你不希望名称被修改，又想发出不要从外部修改属性或方法的信号，可用一个下划线打
# 头。这虽然只是一种约定，但也有些作用。例如，from module import *不会导入以一个下划线
# 打头的名称。

以双下划线 __ 开头（但不以双下划线结尾）时，Python 会自动对方法名进行名称修饰（name mangling）。这是为了避免子类意外地覆盖父类的方法。
当类定义中的方法以双下划线开头时，Python 会将方法名修饰为 _ClassName__method 的形式。这样做的目的是在类的外部阻止对该方法的直接访问，从而提供一定程度的封装和保护。
在 Python 中，以双下划线 __ 开头和结尾的方法是特殊的魔术方法（magic methods）或称为双下划线方法（dunder methods）。
在 Python 中，以单个下划线 _ 开头的方法或属性被视为私有的。这是一种约定，用于表示该方法或属性是供内部使用的，不应在类的外部直接访问。

类的命名空间


class MemberCounter:
    members = 0 
    def init(self): 
        MemberCounter.members += 1

#  MemberCounter.members 是一个类级的变量, 相当与java中静态变量/成员属性
m1 = MemberCounter() 
m1.init() 
print(MemberCounter.members) 
 
m2 = MemberCounter() 
m2.init() 
print(MemberCounter.members)

m1.members = 'Two'
print(m1.members) # two
# 产生的实例对象的属性 遮盖了 类的属性
print(MemberCounter.members) # 2

指定超类/父类


class Filter:
    def init(self):
        self.blocked = []

    def filter(self, sequence):
        return [x for x in sequence if x not in self.blocked]


class SPAMFilter(Filter):  # SPAMFilter 是 Filter 的子类
    def init(self):  # 重写
        self.blocked = ['SPAM']


f = Filter()
f.init()
f.filter([1, 2, 3])

s = SPAMFilter()
s.init()
s.filter(['SPAM', 'SPAM', 'SPAM', 'SPAM', 'eggs', 'bacon', 'SPAM'])

# 判断一个类是否是另一个类的子类 使用内置方法issubclass
print(issubclass(SPAMFilter, Filter))

# 查看类的基类
print(SPAMFilter.__bases__)
print(Filter.__bases__)

s = SPAMFilter()
print(isinstance(s, SPAMFilter))
print(isinstance(s, Filter))
print(isinstance(s, object))

# True True True

print(isinstance("sss", str))
# True

print(s.__class__)

多个超类

class Calculator:
    def calculate(self, expression):
        self.value = eval(expression)

class Talker:
    def talk(self):
        print('Hi, my value is', self.value)

class TalkingCalculator(Calculator, Talker):
    pass

tc = TalkingCalculator()
tc.calculate('1+2+2')
tc.talk()

print(TalkingCalculator.__bases__)
# 如果多个超类以不同的方式实现了同一个方法（即有多个同名方法），必须在class语句中小心排列这些超类，因为位于前面的类的方法将覆盖位于后面
# 的类的方法。

接口和内省

在Python中，不显式地指定对象必须包含哪些方法才能用作参数。例如，你不会像在Java中那样显式编写接口，而是假定对象能够完成你要求它完成的任务。如果不能完成，程序将失败。
通常，你要求对象遵循特定的接口（即实现特定的方法），但如果需要，也可非常灵活地提出要求：不是直接调用方法并期待一切顺利，而是检查所需的方法是否存在；如果不存在，就改弦易辙。

class Calculator:
    def calculate(self, expression):
        self.value = eval(expression)


class Talker:
    def talk(self):
        print('Hi, my value is', self.value)


class TalkingCalculator(Calculator, Talker):
    pass


tc = TalkingCalculator()

hasattr(tc, 'talk')
callable(getattr(tc, 'talk', None))

# 设置对象属性
setattr(tc, 'name', 'Mr. Gumby')
tc.name
print(dir(tc))
print(tc.__dict__)

要查看对象中存储的所有值，可检查其__dict__属性。如果要确定对象是由什么组成的，应
研究模块inspect。这个模块主要供高级用户创建对象浏览器（让用户能够以图形方式浏览Python
对象的程序）以及其他需要这种功能的类似程序。

抽象基类

然而，有比手工检查各个方法更好的选择。在历史上的大部分时间内，Python几乎都只依赖于鸭子类型，即假设所有对象都能完成其工作，同时偶尔使用hasattr来检查所需的方法是否存在。很多其他语言（如Java和Go）都采用显式指定接口的理念，而有些第三方模块提供了这种理念的各种实现。最终，Python通过引入模块abc提供了官方解决方案。这个模块为所谓的抽象基类提供了支持

一般而言，抽象类是不能（至少是不应该）实例化的类，其职责是定义子类应实现的一组抽象方法。

在常规类型中，我们能否在一个特定场景中使用某个对象取决于这个对象的类型，而在鸭子类型中，则取决于这个对象是否具有某种属性或者方法——即只要具备特定的属性或方法，能通过鸭子测试，就可以使用。

from abc import ABC, abstractclassmethod

class Talker(ABC):
    @abstractclassmethod
    def talk(self):
        pass

class Knigget(Talker):
    def talk(self):
        print("Ni!")
        
k = Knigget()
print(isinstance(k, Talker))
k.talk()

class Herring:
    def talk(self):
        print("Blub")
h = Herring()
print(isinstance(h, Talker))

def talk(sb):
    sb.talk()

talk(Knigget())
talk(Herring())
# Herring 不是基类的对象, 但能通过基类对象的检查


from herring import Herring
from abc import ABC, abstractclassmethod


class Talker(ABC):
    @abstractclassmethod
    def talk(self):
        pass


class Knigget(Talker):
    def talk(self):
        print("Ni!")


Talker.register(Herring)
# register 方法注册为子类
h = Herring()
print(isinstance(h, Herring))
h.talk()

# 然而，这种做法存在一个缺点，就是直接从抽象类派生提供的保障没有了, 显示继承抽象类必须实现
# 其中的方法, 注册成为的子类则无法承诺实现了其中的方法.

异常

raise 语句

要引发异常，可使用raise语句，并将一个类（必须是Exception的子类）或实例作为参数。将类作为参数时，将自动创建一个实例。


raise Exception("suka blyat")
# 产生异常, 和java 中的 throw 差不多

# %%
try:
    x = int(input('Enter the first number: '))
    y = int(input('Enter the second number: '))
    print(x / y)
except ZeroDivisionError:
    print("The second number can't be zero!")

# %%
# 捕获异常后，如果要重新引发它（即继续向上传播），可调用raise且不提供任何参数（也可
# 显式地提供捕获到的异常，


class MuffledCalculator:
    muffled = False

    def calc(self, expr):
        try:
            return eval(expr)
        except ZeroDivisionError:
            if self.muffled:
                print('Division by zero is illegal')
            else:
                raise


calculator = MuffledCalculator()
calculator.calc('10 / 2')
# calculator.calc('10 / 0')
# 没启用抑制, 会向上层抛出, 控制台显示异常

calculator.muffled = True
calculator.calc('10 / 0')
# 启用抑制, 不向外层抛出异常

# %%
try:
    1/0
except ZeroDivisionError:
    raise ValueError

# raise 带参数, 引发别的异常, 在这种情况下，导致进入except子句的异常将被作为**异常上下文**存储起来，
# 并出现在最终的错误消息中

# %%

# 使用raise ... from ...语句来提供自己的异常上下文，也可使用None来禁用上下文
try:
    1/0
except ZeroDivisionError:
    # raise ValueError from None
    # raise ValueError from TypeError

异常上下文是指在处理异常时，可以将之前发生的异常信息与当前的异常关联起来，以提供更详细的异常追踪和调试信息。异常上下文允许开发人员在抛出一个新的异常时，指定之前发生的异常作为新异常的原因，从而形成一个异常链。

处理异常

try:
    x = int(input('Enter the first number: '))
    y = int(input('Enter the second number: '))
    print(x / y)
except (ZeroDivisionError, TypeError, NameError, ValueError):
    print('Your numbers were bogus ...')

# %%

try:
    x = int(input('Enter the first number: '))
    y = int(input('Enter the second number: '))
    print(x / y)
except (ZeroDivisionError, ValueError) as e:
    print(e)

# %%
try:
    x = int(input('Enter the first number: '))
    y = int(input('Enter the second number: '))
    print(x / y)
except:
    print('Something wrong happened ...')
# 不指定参数会捕获全部异常

'''
像这样捕获所有的异常很危险，因为这不仅会隐藏你有心理准备的错误，还会隐藏你没有考
虑过的错误。这还将捕获用户使用Ctrl + C终止执行的企图、调用函数sys.exit来终止执行的企图
等。在大多数情况下，更好的选择是使用except Exception as e并对异常对象进行检查。这样做
将让不是从Exception派生而来的为数不多的异常成为漏网之鱼，其中包括SystemExit和
KeyboardInterrupt，因为它们是从BaseException（Exception的超类）派生而来的。
'''

# %% 使用else
while True:
    try:
        x = int(input('Enter the first number: '))
        y = int(input('Enter the second number: '))
        value = x / y
        print('x / y is', value)
    except Exception as e:
        print('Invalid input:', e)
        print('Please try again')
    else:
        break
# 发生异常, 程序中断不会执行else

# %%
try:
    1 / 0
except:
    print("Unknown variable")
else:
    print("That went well!")
finally:
    print("Cleaning up.")

函数与异常

异常和函数有着天然的联系。如果不处理函数中引发的异常，它将向上传播到调用函数的地方。如果在那里也未得到处理，异常将继续传播，直至到达主程序（全局作用域）。如果主程序中也没有异常处理程序，程序将终止并显示栈跟踪消息。

def faulty():
    raise Exception('Something is wrong')


def ignore_exception():
    faulty()


def handle_exception():
    try:
        faulty()
    except:
        print('Exception handled')


# ignore_exception()


handle_exception()

'''
faulty中引发的异常依次从faulty和ignore_exception向外传播，最终导致显示
一条栈跟踪消息。
调用handle_exception时，异常最终传播到handle_exception，并被这里的
try/except语句处理。
'''

obj = {}
try:
    obj.write
except AttributeError:
    print('The object is not writeable')
else:
    print('The object is writeable')

不那么异常的情况

如果你只想发出警告，指出情况偏离了正轨，可使用模块warnings中的函数warn。

from warnings import filterwarnings
from warnings import warn
warn("cuka blyat!!")


# %%
filterwarnings("ignore")
warn("test")
filterwarnings("error")
warn("bad")

'''
发出警告时，可指定将引发的异常（即警告类别），
但必须是Warning的子类。如果将警告转换为错误，将使用你指定的异常。另外，还可根据异常
来过滤掉特定类型的警告。
'''

# %%
filterwarnings("error")
warn("This function is really old...", DeprecationWarning)

# %%
filterwarnings("ignore", category=DeprecationWarning)
warn("Another deprecation warning.", DeprecationWarning) 
warn("Something else.")

魔法方法、特性和迭代器

在Python中，有些名称很特别，开头和结尾都是两个下划线。如__future__。这样的拼写表示名称有特殊意义，因此绝不要在程序中创建这样的名称。在这样的名称中，很大一部分都是魔法（特殊）方法的名称。如果你的对象实现了这些方法，它们将在特定情况下（具体是哪种情况取决于方法的名称）被Python调用，而几乎不需要直接调用。

有些功能（如特性和函数super）不适用于旧式类, __metaclass__ = type 能将旧类(Python3之前)转换为新式类, 即设置当前类的元类（metaclass）, 元类是其他类所属的类. 或者手动继承自一个新式类, 如Object

构造函数

class FooBar:
    def __init__(self):
        self.somevar = 42

f = FooBar()
f.somevar

Python提供了魔法方法__del__，也称作析构函数（destructor）。这个方法在对象被销毁
（作为垃圾被收集）前被调用，但鉴于你无法知道准确的调用时间，建议尽可能不要使用__del__。

super 调用超类构造函数

class Bird:
    def __init__(self):
        self.hungry = True

    def eat(self):
        if self.hungry:
            print('Aaaah ...')
            self.hungry = False
        else:
            print('No, thanks!')


class SongBird(Bird):
    def __init__(self):
        super().__init__()
        # 或者 Bird.__init__(self) # 调用未关联的超类的构造函数, 相当于一个指向父类的指针
        self.sound = 'Squawk!'

    def sing(self):
        print(self.sound)


sb = SongBird()
sb.eat()

# %%


class SongBird2(Bird):
    def __init__(self):
        Bird.__init__(self)  # 调用未关联的超类的构造函数, 使得父类中初始化的hungry存在
        self.sound = 'Squawk!'

    def sing(self):
        print(self.sound)


sb = SongBird2()
sb.eat()

元素访问

基本的序列和映射协议非常简单，但要实现序列和映射的所有功能，需要实现很多魔法方法。

在Python中，协议通常指的是规范行为的规则
在Python中，多态仅仅基于对象的行为（而不基于祖先，如属于哪个类或其超类等, 所谓鸭子类型），因此这个概念很重要：其他的语言可能要求对象属于特定的类或实现了特定的接口，而Python通常只要求对象遵循特定的协议。

基本的序列和映射协议

序列和映射基本上是元素（item）的集合，要实现它们的基本行为（协议），不可变对象需要实现2个方法，而可变对象需要实现4个。

len(self)：这个方法应返回集合包含的项数，对序列来说为元素个数，对映射来说为键值对数。如果__len__返回零（且没有实现覆盖这种行为的__nonzero__），对象在布尔上下文中将被视为假（就像空的列表、元组、字符串和字典一样）。
getitem(self, key)：这个方法应返回与指定键相关联的值。对序列来说，键应该是0~n-1的整数（也可以是负数，这将在后面说明），其中n为序列的长度。对映射来说，键可以是任何类型。
setitem(self, key, value)：这个方法应以与键相关联的方式存储值，以便以后能够使用__getitem__来获取。当然，仅当对象可变时才需要实现这个方法。
delitem(self, key)：这个方法在对对象的组成部分使用__del__语句时被调用，应删除与key相关联的值。同样，仅当对象可变（且允许其项被删除）时，才需要实现这个方法。

对于这些方法，还有一些额外的要求:

对于序列，如果键为负整数，应从末尾往前数。换而言之，x[-n]应与x[len(x)-n]等效。
如果键的类型不合适（如对序列使用字符串键），可能引发TypeError异常。
对于序列，如果索引的类型是正确的，但不在允许的范围内，应引发IndexError异常。

要了解更复杂的接口和使用的抽象基类（Sequence），请参阅有关模块collections的文档。


def check_index(key):
    if not isinstance(key, int):
        raise TypeError
    if key < 0:
        raise IndexError

# 无穷序列


class ArithmeticSequence:
    def __init__(self, start=0, step=1):
        self.start = start
        self.step = step
        self.changed = {}

    def __getitem__(self, key):
        check_index(key)
        try:
            return self.changed[key]
        except KeyError:
            return self.start + key*self.step

    def __settime__(self, key, value):
        check_index(key)
        self.changed[key] = value


s = ArithmeticSequence(1, 2) 
print(s[4])

从 list、dict 和 str 派生

# 带计数器的list
class CounterList(list):
    def __init__(self, *args):
        super().__init__(*args)
        self.counter = 0

    def __getitem__(self, index):  # 访问元素列表, counter++
        self.counter += 1
        return super(CounterList, self).__getitem__(index)


c1 = CounterList(range(10))
print(c1)
c1.reverse()
print(c1)
del c1[3:6]
print(c1)
print(c1.counter)
c1[1]+c1[3]+c1[4]
print(c1.counter)

特性

通过存取方法定义的属性通常称为特性（property）。

函数 property


class Rectangle:
    def __init__(self):
        self.width = 0
        self.height = 0

    def set_size(self, size):
        self.width, self.height = size

    def get_size(self):
        return self.width, self.height
    size = property(get_size, set_size)
    # 这些参数分别名为fget、fset、fdel和doc。


r = Rectangle()
r.width, r.height = 10, 5
print(r.size)

# %%


class MyClass:
    def __init__(self):
        self._my_property = None

    def get_my_property(self):
        # 在这里定义属性的读取操作
        return self._my_property

    def set_my_property(self, value):
        # 在这里定义属性的设置操作
        self._my_property = value

    def del_my_property(self):
        # 在这里定义属性的删除操作
        del self._my_property

    my_property = property(get_my_property, set_my_property,
                           del_my_property, "mydoc")


obj = MyClass()
print(obj.my_property)  # 读取属性值
obj.my_property = 42  # 设置属性值
print(obj.my_property)  # 读取属性值
del obj.my_property  # 删除属性

property提供了一种以属性访问器的方式对属性进行定义和操作的机制。它使您能够在属性访问过程中执行自定义的逻辑，提供更好的封装、控制和灵活性，同时保持代码的可读性和可维护性

通过装饰器来实现的另一种方法

class MyClass:
    def __init__(self):
        self._my_property = None

    @property
    def my_property(self):
        # 在这里定义属性的读取操作
        return self._my_property

    @my_property.setter
    def my_property(self, value):
        # 在这里定义属性的设置操作
        self._my_property = value

    @my_property.deleter
    def my_property(self):
        # 在这里定义属性的删除操作
        del self._my_property


obj = MyClass()
print(obj.my_property)
obj.my_property = 1
print(obj.my_property)
del obj.my_property

静态方法, 类方法

静态方法和类方法在Python中具有一些不同的特点和用法。

静态方法（Static Method）：

静态方法是属于类的方法，而不是属于类的实例的方法。
它们在类中定义，并且可以直接通过类名调用，无需创建类的实例。
静态方法没有对类或实例的隐式引用，因此它们无法访问类或实例的属性和方法。
静态方法通常用于实现与类相关的辅助功能，不需要访问类的状态或属性。

类方法（Class Method）：

类方法是属于类的方法，而不是属于类的实例的方法。
它们在类中定义，并且可以通过类名或类的实例调用。
类方法的第一个参数通常被命名为cls，它指向类本身而不是类的实例。
类方法可以访问和修改类级别的属性，也可以通过cls参数调用其他类方法。

静态方法和类方法的区别在于它们的调用方式和对类或实例的引用方式。静态方法是通过类名直接调用的，没有对类或实例的引用；而类方法可以通过类名或类的实例调用，并且可以通过cls参数访问类级别的属性和方法。

使用静态方法和类方法可以更好地组织和管理代码，使其更具可读性和可维护性。静态方法适用于与类相关的辅助功能，而类方法适用于需要访问和操作类级别属性和方法的情况。

class MyClass:
    def smeth():
        print('This is a static method')
    smeth = staticmethod(smeth)

    def cmeth(cls):
        print('This is a class method of', cls)
    cmeth = classmethod(cmeth)


obj = MyClass()
MyClass.smeth()
MyClass.cmeth()
obj.cmeth()

# 虽然可以, 但最好不要用实例来访问静态方法
obj.smeth()
'''
静态方法的定义中没有参数self，可直接通过类来调用。类方法的定义中包含类似于self的参数，通常被命
名为cls。对于类方法，也可通过对象直接调用，但参数cls将自动关联到类。
'''

# %%


class MyClass:
    @staticmethod
    def smeth():
        print('This is a static method')

    @classmethod
    def cmeth(cls):
        print('This is a class method of', cls)

getattr, setattr 等

getattribute(self, name)：在属性被访问时自动调用（只适用于新式类）。
getattr(self, name)：在属性被访问而对象没有这样的属性时自动调用。
setattr(self, name, value)：试图给属性赋值时自动调用。
delattr(self, name)：试图删除属性时自动调用。

__getattribute__在属性被访问之前被调用，而__getattr__在属性访问失败后被调用
尽量使用property而不是这些特殊方法


class Rectangle:
    def __init__(self):
        self.width = 0
        self.height = 0

    def __setattr__(self, name, value):
        if name == 'size':
            self.width, self.height = value
        else:
            self.__dict__[name] = value

    def __getattr__(self, name):
        if name == 'size':
            return self.width, self.height
        else:
            raise AttributeError()

    def __getattribute__(self, name):
        if name == 'area':
            return self.width * self.height
        else:
            return super().__getattribute__(name)


obj = Rectangle()
obj.__setattr__('size', (2, 4))
print(obj.__getattr__('size'))

print(obj.__getattribute__('width'))
print(obj.width)
print(obj.area)

迭代器

方法__iter__返回一个迭代器，它是包含方法__next__的对象，而调用这个方法时可不提供
任何参数。当你调用方法__next__时，迭代器应返回其下一个值。如果迭代器没有可供返回的值，
应引发StopIteration异常。你还可使用内置的便利函数next，在这种情况下，next(it)与
it.next()等效。

class Fibs:
    def __init__(self):
        self.a = 0
        self.b = 1

    def __next__(self):
        self.a, self.b = self.b, self.a + self.b
        return self.a

    def __iter__(self):
        return self


fibs = Fibs()
for f in fibs:
    if f < 100:
        print(f)
    else:
        break


it = iter([1, 2, 3])
# 获得一个迭代器
print(it.__next__())
print(next(it))

# %% 从迭代器创建序列


class TestIterator:
    value = 0

    def __next__(self):
        self.value += 1
        if self.value > 10:
            raise StopIteration
        return self.value

    def __iter__(self):
        return self


# 更正规的定义是，实现了方法__iter__的对象是可迭代的，而实现了方法__next__的对象是迭代器。
# TestIterator 是一个迭代器, 这个类的对象是可迭代的, iter方法获取迭代器, next 方法进行迭代

ti = TestIterator()
print(list(ti))

生成器

生成器（Generator）和迭代器（Iterator）是Python中用于处理可迭代对象的两种不同的概念。

迭代器（Iterator）：

迭代器是一种实现了迭代器协议的对象，可以通过iter()函数进行迭代。
迭代器对象必须实现__iter__()方法和__next__()方法。
iter()方法返回迭代器对象本身，next()方法返回迭代的下一个值。
迭代器可以一次生成一个值，并且只能向前迭代，不能回溯或重复迭代。
迭代器可以使用for循环进行迭代，也可以使用next()函数手动迭代。
生成器（Generator）：
生成器是一种特殊的迭代器，使用函数或生成器表达式创建。
生成器函数是一个包含yield关键字的函数，它可以暂停和恢复执行。
每次调用生成器函数时，会返回一个生成器对象。
生成器对象可以像迭代器一样进行迭代，每次迭代都会执行生成器函数中的代码，直到遇到yield语句并返回一个值。
生成器可以生成多个值，并且可以灵活地控制生成的值。

总结起来，迭代器是一种实现了迭代器协议的对象，它可以一次生成一个值并向前迭代。而生成器是一种特殊的迭代器，它使用函数或生成器表达式创建，并可以在每次迭代时生成多个值。

生成器相对于迭代器更加灵活和简洁，可以通过生成器函数来定义复杂的迭代逻辑，而不需要显式地实现__iter__()和__next__()方法。此外，生成器还可以使用yield语句来暂停和恢复执行，使得生成器在处理大量数据或无限序列时非常高效。

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


def flatten(nested):
    for sublist in nested:
        for element in sublist:
            yield element

# 包含yield语句的函数都被称为生成器
# 生成器不是使用return返回一个
# 值，而是可以生成多个值，每次一个。每次使用yield生成一个值后，函数都将冻结，即在此停
# 止执行，等待被重新唤醒。被重新唤醒后，函数将从停止的地方开始继续执行。


print(flatten(nested))
for num in flatten(nested):
    print(num)

# %%
# 生成器推导（也叫生成器表达式）。其工作原理与列表推导相同，但不是创建一个列表（即不立即执行循环）
# ，而是返回一个生成器，让你能够逐步执行计算。

g = (i**2 for i in range(0, 10))
print(next(g), next(g))

# 直接在一对既有的圆括号内（如在函数调用中）使用生成器推导时，无需再添加一对圆括号。
print(sum(i**2 for i in range(10)))

递归式生成器

def flatten(nested): 
    try: 
        for sublist in nested: 
            for element in flatten(sublist): 
                yield element 
    except TypeError: 
            yield nested

# %%

def flatten(nested):
    try:
        # 不迭代类似于字符串的对象：
        try:
            nested + ''
        except TypeError:
            pass
        else:
            raise TypeError
        for sublist in nested:
            for element in flatten(sublist):
                yield element
    except TypeError:
        yield nested


res = list(flatten([[[1], 2], 3, 4, [5, [6, 7]], 8]))
print(res)
print(list(flatten(['foo', ['bar', ['baz']]])))

通用生成器

生成器是包含关键字yield的函数，但被调用时不会执行函数体内的代码，而是返回一个迭代器。每次请求值时，都将执行生成器的代码，直到遇到yield或return。yield意味着应生成一个值，而return意味着生成器应停止执行（即不再生成值；仅当在生成器调用return时，才能不提供任何参数）。

换而言之，生成器由两个单独的部分组成：生成器的函数和生成器的迭代器。生成器的函数是由def语句定义的，其中包含yield。生成器的迭代器是这个函数返回的结果。用不太准确的话说，这两个实体通常被视为一个，通称为生成器。

对于生成器的函数返回的迭代器，可以像使用其他迭代器一样使用它

生成器的方法

在生成器开始运行后，可使用生成器和外部之间的通信渠道向它提供值。这个通信渠道包含如下两个端点。

外部世界：外部世界可访问生成器的方法send，这个方法类似于next，但接受一个参数（要发送的“消息”，可以是任何对象）。
生成器：在挂起的生成器内部，yield可能用作表达式而不是语句。换而言之，当生成器重新运行时yield返回一个值——通过send从外部世界发送的值。如果使用的是next，yield将返回None


def repeater(value):
    while True:
        new = (yield value)
        if new is not None:
            value = new


r = repeater(42)
print(r)
print(next(r))

r.send("hello world")
print(r)
print(next(r))

print(next(r))

生成器还包含另外两个方法。
方法throw：用于在生成器中（yield表达式处）引发异常，调用时可提供一个异常类型、一个可选值和一个traceback对象。

方法close：用于停止生成器，调用时无需提供任何参数。
方法close（由Python垃圾收集器在需要时调用）也是基于异常的：在yield处引发
GeneratorExit异常。因此如果要在生成器中提供一些清理代码，可将yield放在一条try/finally
语句中。如果愿意，也可捕获GeneratorExit异常，但随后必须重新引发它（可能在清理后）、引
发其他异常或直接返回。对生成器调用close后，再试图从它那里获取值将导致RuntimeError异常。


# 模拟生成器
def flatten(nested):
    result = []
    try:
        # 不迭代类似于字符串的对象：
        try:
            nested + ''
        except TypeError:
            pass
        else:
            raise TypeError
        for sublist in nested:
            for element in flatten(sublist):
                result.append(element)
    except TypeError:
        result.append(nested)
    return result

# 这无法模拟无穷生成器，因为显然不能将这种生成器的值都存储到一个列表中

八皇后问题


import random


def conflict(state, nextX):
    nextY = len(state)
    for i in range(nextY):
        if abs(state[i]-nextX) in (0, nextY-i):
            # 如果下一个皇后和当前皇后的水平距离为0（在同一列）或与它们的垂直距离相等（位于一
            # 条对角线上），这个表达式就为真；否则为假。
            return True
    return False


def queens(num=8, state=()):
    for pos in range(num):
        if not conflict(state, pos):
            if len(state) == num-1:
                yield(pos,)
            else:
                for result in queens(num, state+(pos,)):
                    yield (pos,)+result


def prettyprint(solution):
    def line(pos, length=len(solution)):
        return '. ' * (pos) + 'X ' + '. ' * (length-pos-1)
    for pos in solution:
        print(line(pos))


prettyprint(random.choice(list(queens(8))))

其他

关于name == ‘main’

当执行当前模块, 全局变量__name__ == ‘main’, 而引入的其他模块中的 name 为其模块名. 这个布尔表达式可以用来判断执行的模块是否是主模块, 可以用来测试当前模块的函数(被主模块引入时值为False不会执行快中语句). 这也是由于python没有主函数, 每次会执行引入的所有语句, 故要区分不同模块中的函数调用, 就像其他语言中的规定入口函数只能有一个.

dir()

dir() 函数是 Python 的一个内置函数，用于返回指定对象的所有属性和方法。当不带参数调用时，它会返回当前范围内的变量、方法和定义的类型列表；当带参数调用时，它会返回参数的属性和方法列表。

repr()

将对象转换成字符串

# -*- coding: utf-8 -*-

print(repr("test"))
print(repr((1, 2, 3)) + "good") 
# 'test'
#(1, 2, 3)good
print(str([1,2])+ "good")
# [1, 2]good

字符串（以及数和元组）是不可变的（immutable）

参考

Author:
slacr_
Copyright:
Published:
September 7, 2023
Updated:
September 7, 2023

Buy me a cup of coffee ☕.

支