标签：__ 结果 Python self 列表 Note print def

Python Note

ctrl + c 强制终端程序

alt + p 重复调出上个语句

BIF(Buid-in Functions )是Python的内置函数，为了方便程序员快捷编写脚本程序。

len(dir(builtins)):158 python 3.12.5内置函数有158个

收集参数：*args和**kwargs的理解

打包（pack）：*args是把多个位置参数打包成元组，** kwargs是把多个关键字参数打包成字典。

拆分（unpack）：* args是把打包了的参数拆成单个的，依次赋值给函数的形参，** kwargs是把字典的键值拆成单个的，依次赋值给函数的形参。

#*args,*作用，有两个：打包参数和拆分参数

#打包参数，将函数的五个参数打包成一个元组输出
def foo(*args):
    for i in args:
        print(i)
    print(type(args))

foo(1,2,3,4,5)

#拆分参数，将列表或是元组进行拆分
def bar(a, b, c, d=10):
    print(a, b, c, d)


bar(*[1, 2, 3])


# **kwargs,**的作用，分两种：打包参数（pack）和拆分参数(unpack)
'''
打包（pack）：*args是把多个位置参数打包成元组，**kwargs是把多个关键字参数打包成字典。
拆分（unpack）：*args是把打包了的参数拆成单个的，依次赋值给函数的形参，**kwargs是把字典的键值拆成单个的，依次赋值给函数的形参。
'''
# **kwargs是把多个关键字参数打包成字典
def bar(**number):
    print(number)


bar(a=1, b=2, c=3)

# **kwargs是把字典的键值拆成单个的，依次赋值给函数的形参。

def bar(a, b, c):
    print(a,b,c)


bar(**{'a': 1, 'b': 2, 'c': 3})

运算符

算术运算符

• +、-、*、/ ...

• divmod(x, y)：返回（x//y,x%y）地板除值和余数

  • 地板除返回比真正的商小的，最接近的数字
  • 余数不能为负数

• abs(x) ：x的绝对值

• 复数，如：z = 1 + 2j，实部为1，虚部为2

• complex(re,im) ：返回一个复数，re是实部，im是虚部

  • complex("2+3j")，字符串中间不能有空格

• 布尔类型(特殊的整数类型)

  • 结果为False的所有情况：
    • 定义为False的对象：None和False
    • 值为0的数字类型：0,0.0,0j,Decimal(0),Fraction(0,1)
    • 空的序列和集合：'',(),[],{},set(),range(0)

比较运算符

• ==、>=...

赋值运算符

• =、+=、-= ...

逻辑运算符

• and
• or
• not

成员运算符

• in
• not in

常见数据结构

字符串、列表、元组与集合、字典

字符串

\，转义符，\n：换行

列表

列表是有序的集合

添加：append，extend，insert

L = []
L.append('1')#只能添加一个元素
print(L)#结果为：['1']
L.extend(['2','3','4'])#可添加多个元素，参数必须是一个可迭代对象，追加在原列表最后一个元素后面
print(L)#结果为：['1','2','3','4']
L.insert(0,0)#在下标为0的位置添加数字0
L.insert(len(L),6)#在下标为列表长度的位置添加数字6

删除：del，remove，pop，clear

L = ['1','2']
del L[0]#填入下标
print(L)#结果为：['2']
L.remove('2')#填入指定元素，若元素不存在会报错
print(L)#结果为空

L = ['1','2','3']
L.pop()
print(L)#结果为：['1','2']，默认弹出最后一个元素，并输出结果

L.pop(0)
print(L)#结果为：['2'],可以指定位置弹出元素

L = ['1','2','3']
L.clear()
print(L)#结果为空列表

修改：

L = [1,2,3,4]
L[3] = 5
print(L)#结果为：[1,2,3,5]

排序：sort/sorted

sort改版列表本身排序

L = [7,3,4,1,1,2,3]
L.sort()
print(L)#结果为：[1,1,2,3,3,4,7],默认为升序排，想降序排列在sort(reverse=True)

sorted不改变原列表排序

L = [7,3,4,1,1,2,3]
L1 = L.sorted()
print(L1)#结果为：[1,1,2,3,3,4,7]
print(L)#结果为：[7,3,4,1,1,2,3]

查找：

count，针对某个元素计数,count(sub[,start[,end]])

L = [7,3,4,1,1,2,3]
L.count(1)#结果为2
str1 = '上海自来水来自海上'
L.count('上', 0, 5)#结果为1

index，查看元素的索引值，index(x,start,end)，start和end是可选参数，若为找到抛出异常

L = [7,3,4,1,1,2,3]
L.index(4)#结果为：2
L[L.index(4)] = 5#通过索引值替换相关元素，只改变首个
print(L)#结果为：[7,3,5,1,1,2,3]

find，find(x,start,end)若为找到返回值为-1

str2 = '床上女子叫子女上床'
str2.find('女子')
2

copy，浅拷贝（只是拷贝了外层的对象，如果包含嵌套对象，拷贝的只是其引用）

L = [7,3,4,1,1,2,3]
#方法一
L_copy1 = L.copy()
print(L_copy1)#结果为：[7,3,4,1,1,2,3]
#方法二
L_copy2 = L[:]
print(L_copy2)#结果为：[7,3,4,1,1,2,3]

x = [[1,2,3],[4,5,6]]
y = x.copy()
x[1][1] = 0#结果：[[1,2,3],[4,0,6]]
y#结果会被同时修改：[[1,2,3],[4,0,6]]

import copy
x = [[1,2,3],[4,5,6]]
y = copy.copy(x)#copy模块的copy函数
x[1][1] = 0#结果：[[1,2,3],[4,0,6]]
y#结果会被同时修改：[[1,2,3],[4,0,6]]

copy，深拷贝（deepcopy函数将原对象拷贝的同时，也将对象所引用的子对象也拷贝，深拷贝效率低）

x = [[1,2,3],[4,5,6]]
y = copy.deepcopy(x)#copy模块的copy函数
x[1][1] = 0#结果：[[1,2,3],[4,0,6]]
x#结果：[[1,2,3],[4,0,6]]
y#结果：[[1,2,3],[4,5,6]]

嵌套列表，在列表中嵌套新的列表

matrix = [[1,2,3],[4,5,6],[7,8,9]]
for i in matrix:
	for each in i:
        print(each, end=' ')

列表推导式

列表推导式比循环执行速度要快

结构：[expression(表达式) for target in iterable]

matrix = [[1,2,3],
          [4,5,6],
          [7,8,9]]
code = [row[1] for row in matrix]#code结果为：[2,5,8]
code = [matrix[i][i] for i in range(len(matrix))] #左上角到右下角结果为：[1,5,9]
code = [matrix[i][len(matrix)-1-i] for i in range(len(matrix))] #右上角到左下角：[3,5,7]

注意：循环是通过迭代来逐个修改原列表中的元素，列表推导式是创建新列表然后再赋值为原先的变量

B = [[0] * 3] * 3 #创建了一个假二维列表，给其中一个元素赋值则会影响三个元素，此方式三个指针指向同一个值

#可行方式
#方法一：
A = [0] * 3
for i in range(3):
    A[i] = [0] * 3
#方法二：
s = [[0] * 3 for i in range(3)]

结构：[expression for target in iterable if condition]

先执行for语句再执行if语句最后执行表达式

#筛选出F字幕开头的元素
words = ["Great","FishC","Briilliant","Excellent","Fantistic"]
fwords = [i for i in words if i[0] == 'F']

结构：[expression for target1 in iterable1

​ for target2 in iterable2

​ ...

​ for targetN in iterableN]

[x + y for x in "fishc" for y in "FISHC"]
结果为又称笛卡尔乘积：['fF', 'fI', 'fS', 'fH', 'fC', 'iF', 'iI', 'iS', 'iH', 'iC', 'sF', 'sI', 'sS', 'sH', 'sC', 'hF', 'hI', 'hS', 'hH', 'hC', 'cF', 'cI', 'cS', 'cH', 'cC']

_ = []#无关紧要的变量可以用'_'代替

结构：[expression for target1 in iterable1 if conditon1

​ for target2 in iterable2 if conditon2

​ ...

​ for targetN in iterableN if conditonN]

[[x,y] for x in range(10) if x % 2 == 0 for y in range(10) if y % 3 == 0]
结果为：
[[0, 0], [0, 3], [0, 6], [0, 9], [2, 0], [2, 3], [2, 6], [2, 9], [4, 0], [4, 3], [4, 6], [4, 9], [6, 0], [6, 3], [6, 6], [6, 9], [8, 0], [8, 3], [8, 6], [8, 9]]

程序设计原则：KISS(Keep It Simple & Stupid) 简洁胜于复杂

元组

t = (1,'fishc',3.14) #打包，列表、字符串也有打包和解包的功能
#解包，字符串左边的数量必须和右边序列的元素数量一致，若数量不能精准把控，可采取 a,*b = t
x,y,z = t# 结果：x = 1, y = 'fishc', z = 3.14
a,*b = t# 结果为：x = 1, b = ['fishc', 3.14]

x,y = 10,20 #原理，先进行打包在进行解包: _ = 10,20 -> x,y = _

字符串

x = "I love FishC"
x.capitalize()#首字母大写
x.casefold()#转换为小写，适用的语言更广泛
x.title()#每个字母开头大写
x.swapcase()#大小写反转
x.upper()#全部转化为大写
x.lower()#转换为小写
x.center(15,"淦")#左右两侧加15字符宽带
x.ljust(15)#左对齐
x.rjust(15)#右对齐
x.zfill(15)#在左侧用0添加多余的宽度

序列

s = [1,2,3]
id(s)#id()此BIF函数获取唯一标志的整数值并返回

'''
is和is not 同一性运算符
in和not in 包含运算符
del 删除变量（也可利用切片）
'''
del s #删除了s列表,斩草除根式

s = [1,2,3]
del s[:]#清空列表

#max,min 格式max(列表，default="")
#enumerate()枚举对象
seasons = ["Spring","Summer","Fall","Winter"]
enumerate(seasons)
list(enumerate(seasons))#结果为：[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

#zip()创建一个聚合多个可迭代对象的迭代器
x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
list(zipped)#[(1, 4), (2, 5), (3, 6)]

z = "FishC"
zipped = zip(x, y, z)
list(zipped)#[(1, 4, 'F'), (2, 5, 'i'), (3, 6, 's')]不全面
import itertools
zipped = itertools.zip_longest(x, y, z)
list(zipped)#[(1, 4, 'F'), (2, 5, 'i'), (3, 6, 's'), (None, None, 'h'), (None, None, 'C')]

#map()函数会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将返回运算结果的迭代器。
mapped = map(ord,"Fishc")#ord：求出传入字符对应的 unicode编码
list(mapped)#结果：[70, 105, 115, 104, 99]
mapped = map(pow,[2, 3, 10],[5, 2, 3])#计算2**5,3**2,10**3
list(mapped)#结果：[32, 9, 1000]
#filter()函数（过滤器）会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将运算结果为真的元素，以迭代器的方式返回
list(filter(str.islower,"FishC"))#结果为：['i', 's', 'h']

#迭代器和可迭代对象，一个迭代器肯定是一个可迭代对象，可迭代对象可以重复使用而迭代器则是一次性的
#异常是可控的，错误是不可控的
x = [1, 2, 3, 4, 5]
y = iter(x)#迭代器
type(y)#<class 'list_iterator'>
#元素调用方法用next()
next(y)#迭代器内元素调用完时会有报异常
...
#解决异常的方法
y = iter()
next(y,"掏空了！")
1
next(y,"掏空了！")
2
next(y,"掏空了！")
3
next(y,"掏空了！")
4
next(y,"掏空了！")
5
next(y,"掏空了！")
'掏空了！'

字典

字典是Python中唯一实现了映射关系的内置类型。键不可重复，值可重复。

#创建字典的方式有六中
a = {"吕布":"口口布", "关羽":"关习习"}
b = dict(吕布="口口布", 关羽="关习习")
c = dict([("吕布","口口布"),("关羽","关习习")])
d = dict({"吕布":"口口布", "关羽":"关习习"})
e = dict({"吕布":"口口布"}, 关羽 = "关习习")
f = dict(zip(["吕布","关羽"],["口口布","关习习"]))

#fromkeys快速初始化字典值的方法
d = dict.fromkeys("Fishc", 251)#结果：{'F': 251, 'i': 251, 's': 251, 'h': 251, 'c': 251}
#pop删除字典元素
d.pop('s')#弹出值，并删除该键值对
d.popitem()#弹出最后一个值，并删除该键值对
#del
del d #删除字典,重新查找该字典时弹出异常
#clear 清空字典
d.clear()#结果：{}

#改
d = dict.fromkeys("FishC")
d.update({'i':105, 'h':104})#结果：{'F': None, 'i': 105, 's': None, 'h': 104, 'C': None}
d.update(F='70', C='60')#结果：{'F': '70', 'i': 105, 's': None, 'h': 104, 'C': '60'}

#查
d.get('c',"这里没有c")#结果:'这里没有c'
d.setdefault('c', "code")#若字典中无该键，则添加新键值对进入字典

#items() keys() values()键值对三者的视图对象，视图对象：即字典的动态视图，当字典改变时，三者会同时更新
keys = d.keys() #键
values = d.values()#值
items = d.items()#键值对
list(reversed(d.values()))#将字典按值按倒序排序

#字典推导式
d = {'F':70, 'i':105, 's':115, 'h':104, 'C':67}
b = {v:k for k,v in d.items()}#将键和值互换：{70: 'F', 105: 'i', 115: 's', 104: 'h', 67: 'C'}
d = {x:ord(x) for x in "FishC"}#结果：{'F': 70, 'i': 105, 's': 115, 'h': 104, 'C': 67}
d

集合

#集合是无序的，因此无法以下标形式进行访问，可通过in or not in 来判断元素是否存在于集合中
{s for s in "FishC"}#{'i', 'F', 'C', 'h', 's'}
#集合自动去重
set([1, 1, 2, 3, 5])#结果：{1, 2, 3, 5}

#isdisjoint()判断元素是否有共同元素
s = set("FishC")
s.isdisjoint(set("Python"))#结果：False
s.isdisjoint(set("JAVA"))#结果：True
#是否是子集
s.issubset("FishC.com.cn")#True
#超集，可填写多个参数
s.issubset("FishC")#True
#并集，可填写多个参数
s.union({1, 2, 3})#{'F', 'C', 'i', 'h', 1, 2, 3, 's'}
#交集，可填写多个参数
s.intersection("Fish")#{'F', 'i', 'h', 's'}
#差集，可填写多个参数
s.difference("Fish")#{'C'}
#对称差集，只能有一个参数
s.symmetric_difference("Python")#{'i', 'y', 'F', 'C', 'P', 'o', 'n', 't', 's'}

#不可变集合,frozenset()函数，将元素冻结（frozen）起来
set1 = frozenset({1, 2, 3, 4, 5})
set1.add(6)#报错
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    set1.add(6)
AttributeError: 'frozenset' object has no attribute 'add'

函数

闭包，该概念是由内部函数而来，所以不能再外部函数以外的地方对内部函数进行调用

#会报错,在内部函数中，只能对外部函数的局部变量进行访问，不能进行修改
def funX():
    x = 1
    funY():
        x = x + 1
        return x
    return funy

#解决办法，在闭包函数中加入nonlocal关键字，类似global
def funX():
    x = 1
    def funY():
        nonlocal x
        x = x + 1
        return x
    return funY

lambda，是一个匿名函数，是一个函数对象，结构是由lambda 变量 ： 返回值，返回值可加入if语句判断

def funX(x):
    funY(y):
        return x + y
    return funy


#上述代码可以使用lambda关键字来创建匿名函数
def funX(x):
    return lambda y : x + y

#加入if语句的lambda
f = lambda x ： x if x % 2 else None
#相当于
def fun1(x):
    if x % 2:
        return x
    else:
        return None

内置序列函数

循环

continue 跳过本次循环，回到循环开头位置

循环语句被break后，else语句不会正常执行。内层循环正常跑完，才会执行else。

分隔符 split

语法格式

string.split(str="", num=string.count(str))
str1 = "肖申克的救赎/1994年/9.6分/美国"
str1.split(sep='/')
['肖申克的救赎', '1994年', '9.6分', '美国']

参数说明：

1.str:分隔符，默认为所有的空字符，包括空格、换行、水平制表符、垂直制表符、换页、回车

2.num:分隔次数。默认为-1，即分隔所有

拼接符 join

和split()方法相反，join(iterable)方法用于拼接字符串：

countries = ['中国', '美国', '俄罗斯', '日本', '韩国']
'-'.join(countries)
'中国-美国-俄罗斯-日本-韩国'

OS模块（Operating System），操作系统模块

import os
os.getcwd()#获取应用程序当前的工作目录

对象

对象 = 属性 + 方法

封装

通过类把属性和方法打包在一起，然后通过类来生成对象，类中的每一个方法，默认的第一个参数都是self

class D:
    def d():
        print(123)
d = D()
d.d()
Traceback (most recent call last):
  File "<pyshell#42>", line 1, in <module>
    d.d()
TypeError: D.d() takes 0 positional arguments but 1 was given

#分析原因，self:传递给方法的就是实力对象本身
class C:
    def get_self(self):
        print(self)

        
c = C()
c.get_self()
<__main__.C object at 0x000002223DC6E060>
c
<__main__.C object at 0x000002223DC6E060>

继承

class A:
    x = 520
    def hello(self):
        print("你好，我是A")
        
class B:
    x = 8800
    y = 5200
    def hello(self):
        print("你好我是B")

        
class C(A, B):
    pass

c = C()
c.x
520
c.hello() #访问顺序按从左到右
你好，我是A

多重继承和组合

class Turtle():
    def say(self):
        print("不积跬步无以至千里")

        
class Cat():
    def say(self):
        print("喵喵喵~")

        
class Dog():
    def say(self):
        print("呦吼，我是一只小狗")

        
class Garden:
    t = Turtle()
    c = Cat()
    d = Dog()
    def say(self):
        self.t.say()
        self.c.say()
        self.d.say()
g = Garden()
g.say()
不积跬步无以至千里
喵喵喵~
呦吼，我是一只小狗

self实现的功能就是实例对象跟类的方法进行绑定

构造函数 init

class C:
    def __init__(self, x, y):
        self.x = x#左侧self.x 是绑定到实例化对象里面的x属性，右边是传进来的x参数
        self.y = y
    def add(self):
        return self.x + self.y
    def mul(self):
        return self.x * self.y

重写

class D(C):
    def __init__(self, x, y, z):
        C.__init__(self, x, y)
        self.z = z
    def add(self):
        return C.add(self) + self.z
    def mul(self):
        return C.mul(self) * self.z

    
d = D(2, 3, 4)
d.add()
9

钻石继承

class A:
    def __init__(self):
        print("哈喽，我是A~")
        
class B1(A):
    def __init__(self):
        A.__init__(self)
        print("哈喽，我是B1~")

class B2(A):
    def __init__(self):
        A.__init__(self)
        print("哈喽，我是B2~")

class C(B1, B2):
    def __init__(self):
        B1.__init__(self)
        B2.__init__(self)
        print("哈喽，我是C~")
c = C()#classA输出了两次
哈喽，我是A~
哈喽，我是B1~
哈喽，我是A~
哈喽，我是B2~
哈喽，我是C~

'''
改进，利用super(),super()函数能够在父类中搜索指定的方法并绑定self参数，以MRO顺序进行（Method Resolution Order）方法解析顺序。BIF:mro()方法或mro属性__mro__。
例如：
C.mro():
[<class '__main__.C'>, <class '__main__.B1'>, <class '__main__.B2'>, <class '__main__.A'>, <class 'object'>] 

C.__mro__:
(<class '__main__.C'>, <class '__main__.B1'>, <class '__main__.B2'>, <class '__main__.A'>, <class 'object'>)
'''
class B1(A):
    def __init__(self):
        super().__init__()
        print("哈喽，我是B1~")

        
class B2(A):
    def __init__(self):
        super().__init__()
        print("哈喽，我是B2~")

        
class C(B1, B2):
    def __init__(self):
        super().__init__()
        print("哈喽，我是C~")

        
c = C()
哈喽，我是A~
哈喽，我是B2~
哈喽，我是B1~
哈喽，我是C~

习题

取得一个变量的类型，视频中介绍可以使用type()和isinstance()，你更倾向于使用哪个？

共同点：两者都可以判断对象类型

不同点：对于一个 class 类的子类对象类型判断，type就不行了，而 isinstance 可以。

type()可以判断未知变量的类型，目前更倾向于用type()

Python3可以给变量命名中文名，知道是为什么吗？

因为3中源文件默认使用的是UTF-8编码，所以变量名也可以使用中文

*** Python的floor除法现在使用“//”实现，那3.0//2.0你目测会显示什么内容？***

结果是不大于结果的最大整数

请用最快速度说出答案：not 1 or 0and 1 or 3 and 4 or 5 and 6 or 7 and 8 and 9

not or and的优先级是不同的：not> and > or，所以按优先级加上括号是：(not 1) or (0 and 1) or (3 and 4)or (5 and 6) or (7 and 8 and 9) = 0 or 0 or 4 or 6 or 9 = 4

爱因斯坦曾出过这样一道有趣的数学题：有一个长阶梯，若每步上2阶，最后剩1阶；若每步上3阶，最后剩2阶；若每步上5阶，最后剩4阶；若每步上6阶，最后剩5阶；只有每步上7阶，最后刚好一阶也不剩。题目：请编程求解该阶梯至少有多少阶？

  x = 7  
  i = 0  
  flag = 0  
  while i < 100:  
      if (x % 2 == 1) and (x % 3 == 2) and (x % 5 == 4) and (x % 6 == 5):  
          flag = 1  
          break  
      i = i + 1  
      x = 7*i  
 if flag == 1:  
     print("最小阶梯数是：",x)  
 else:  
     print('在这个范围内未找到符合条件的数！')  

*** 猜猜(x < y and [x] or [y])[0]实现什么样的功能？***

这其实是 Python 的作者还没有为 Python 加入三元操作符之前，Python 社区的小伙伴们灵活的使用 and 和 or  搭配来实现三元操作符的功能

*** 你听说过成员资格运算符吗？***

in。用于检查一个值是否在序列中，在就返回True，否则返回False

name = 'allen'
'a' in name #结果为：True

*** 【学会提高代码的效率】你觉得以下代码效率方面怎样？有没有办法可以大幅度改进（任然使用while)***

i = 0  
string = 'ILoveFishC.com'  
while i < len(string):  
    print(i)  
    i += 1  

#改进后，主要是不用每次循环都调用len函数。
i = 0  
string = 'ILoveFishC.com'  
length = len(string)  
while i < length:  
    print(i)  
    i += 1  

*** 有红、黄、蓝三种颜色的求，其中红球 3 个，黄球 3 个，绿球 6 个。先将这 12 个球混合放在一个盒子中，从中任意摸出 8 个球，编程计算摸出球的各种颜色搭配***

print('red\tyellow\tgreen')
for red in range(0,4):
    for yellow in range(0,4):
        for green in range(0,7):
            if red + yellow + green == 8:
                print(red, '\t', yellow, '\t', green)
    

*** 请用一句话描述什么是列表？再用一句话描述什么是元组？***

列表：一个大仓库，你可以随时往里边添加和删除任何东西。

元组：封闭的列表，一旦定义，就不可改变（不能添加、删除或修改）

*** 什么情况下你需要使用元组而不是列表？***

当你需要保存的数据不被轻易更改时，就用元祖

请将下图左边列表的内置方法与右边的注释连线，并圈出元组可以使用的方法

拼接操作符：+

重复操作符：*

逻辑操作符：and，or

成员操作符：in，not in

关系操作符: >，<，<=，>=，==

*** 创建一个元组，什么情况下逗号和小括号必须同时存在，缺一不可？***

>>> tuple1 = ('allen','dragon','小甲鱼','gdut','allegro')  
>>> tuple2 = tuple1[:1] + ('love',) + tuple1[1:]  
>>> tuple2  
('allen', 'love', 'dragon', '小甲鱼', 'gdut', 'allegro')  

*** 还记得如何定义一个跨越多行的字符串吗（请至少写出两种实现的方法）?***

>>> str1 = ('all'  
    'en')  
>>> str1  
'allen'  
>>> str4 = 'all\  
en'  
>>> str4  
'allen'  

编写一个函数，判断传入的字符串参数是否为“回文联”

#正确写法
def huiwen(string): 
    '判断传入的字符串是否为回文联' 
    list1 = list(string)  
    list2 = list(reversed(string))  
    if list1 == list2:  
        return '是回文联'  
    else:  
        return '不是回文联'  
  
print(huiwen('上海自来水来自海上'))  

#错误写法
def huiwen(string):  
    '判断传入的字符串是否为回文联'
    list1 = list(string)  
    list2 = list1.reverse()#返回值为None  
    if list1 == list2:  
        return '是回文联'  
    else:  
        return '不是回文联'  
  
print(huiwen('上海自来水来自海上'))  

在嵌套的函数中，如果希望在内部函数修改外部函数的局部变量，应该使用什么关键字？

#使用 nonlocal 关键字
>>> def outside():  
	    number = 4  
	    def inside():  
	        nonlocal number  
	        number *= number  
	        return number  
	    return inside()  
	  
>>> outside()  
16  

*** 你可以使用filter()和lambda()表达式快速求出100以内所有3的倍数吗？***

>>> list(filter(lambda x : x%3 == 0,range(100)))  
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]  

还记得zip吗？使用zip会将两个数以元组的形式绑定在一起

>>> list(zip([1,3,5,7,9],[2,4,6,8,10]))  
[(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]  

但是如果我希望打包的形式是灵活多变的列表而不是元组（希望是[[1,2],[3,4],[5,6],[7,8],[9,10]]这种形式），你能做到吗？（采用map和lambda表达式）

>>> list(map(lambda x,y : [x,y],range(1,10,2),range(2,10,2)))  
[[1, 2], [3, 4], [5, 6], [7, 8]]  

标签：__,结果,Python,self,列表,Note,print,def
From： https://www.cnblogs.com/lurenj/p/18511887