内建函数与列表常用函数

Posted 2021-01-08 yuanjian6

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了内建函数与列表常用函数相关的知识，希望对你有一定的参考价值。

汉诺塔问题?

规则：

1.每次移动一个盘子

2.任何时候大盘子在下面，小盘子在上面

方法：

1.n = 1 直接把 A 上的盘子移到 C 上去，A->C 2.n = 2 :

    小盘子放到B 上A->B
    把大盘子放到C上 A->C
    把小盘子放到C上 B->C

3.n = 3:

     把A上的两个盘子，通过C移到B上去，调用递归实现
     把A上的最大的盘子移到C上 A->C
     把B上的两个盘子借助A，移到C上去，调用递归实现

4.n = n：

     把A 上的n-1个盘子，借助c移到B上去，调用递归
     把A 上的 最大的盘子移到C上，A->C
     把B上的n-1个盘子，借助A，移到C上去，调用递归

In [4]:

 
 

def hano(n,a,b,c):
    """
    汉诺塔的递归实现
    n:代表几个盒子
    a:代表第一个塔
    b:代表第二个塔
    c:代表第三个塔
     ......
    """
    if n == 1:
        print(a,"-->",c)
        return None
    if n == 2:
        print(a,"-->",b)
        print(a,"-->",c)
        print(b,"-->",c)
        return None
    # 把 n-1 个盘子，借助于 c 塔，移动到 b 塔上去
    hano(n-1,a,c,b)
    print(a,"-->",c)
    # 吧 n-1 个盘子借助于 A 塔，移到c 塔上去
    hano(n-1,b,a,c)

a = "A"
b = "B"
c = "C"
?
n = 1
hano(n,a,b,c)

A --> C

In [5]:

 
n = 2
hano(n,a,b,c)

A --> B
A --> C
B --> C

In [7]:

 
n = 3
hano(n,a,b,c)

A --> C
A --> B
C --> B
A --> C
B --> A
B --> C
A --> C

 
# list （列表）
?
 - del：删除命令

list （列表）?

del：删除命令

In [10]:

 
# del 删除
a = [1,2,3,4,5]
del a[2]
print(a)

[1, 2, 4, 5]

In [11]:

 
 

# del 删除
# 如果使用del 之后，id 的值和使用前不一样，则生成了一个新的 list
a = [1,2,3,4,5]
print(id(a))
del a[2]
print(id(a))
print(a)

1534237784328
1534237784328
[1, 2, 4, 5]

In [12]:

 
# del 一个变量后就不能在使用此变量
del a
print(a)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-12-f7cf5f6cf3fd> in <module>()
      1 # del 一个变量后就不能在使用此变量
      2 del a
----> 3 print(a)

NameError: name ‘a‘ is not defined

 
## 列表相加(相乘)
?
 - 使用加号“ + ”连接两个列表

列表相加(相乘)?

使用加号“ + ”连接两个列表

In [13]:

 
a = [1,2,3,4,5]
b = [11,12,13,14]
d = a + b
print(d)

[1, 2, 3, 4, 5, 11, 12, 13, 14]

 
## 使用乘号操作列表
?
## 列表直接和一个整数相乘

使用乘号操作列表?

列表直接和一个整数相乘?

In [18]:

 
a = [1,2,3,4,5]
b = a * 10
print(b)

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

In [20]:

 
 

## 成员资格运算
?
# 就是判断一个元素是否在 list 里边
?
a = [1,5,9,6,7]
b = 5
# C的值一定是个布尔值
c = b in a
print(c)
?
b = 4 
print(b in a)

True
False

In [21]:

 
# not in
a = [1,5,9,6,7]
b = 10
print(b not in a)

True

 
# 链表的遍历

 - for
 - while

链表的遍历?

for
while

In [22]:

 
 

# for in list
a = [1,5,9,6,7]
?
# 挨个打印出a 里边的元素
for i in a:
    print(i)

In [23]:

 
a = ["I love you"]
for i in a:
    print(i)

I love you

In [24]:

 
## range 
# 在 in 后面的所有变量要求是可以可迭代的内容
for i in range(1,11):
    print(i)

In [ ]:

# while循环访问list， 一般不用 while访问

In [26]:

 
 

a = [1,2,3,4,5]
length = len(a)
# indx 表示的是 list 的下标
indx = 0
while indx < length:
    print(a[indx])
    indx += 1

In [28]:

 
## 双层列表循环
a = [["one",20],["love",50],["pou",60] ]
for k,v in a:
    print(k,"__",v)

one __ 20
love __ 50
pou __ 60

In [29]:

 
## 双层列表循环变异
a = [["one",20,"onr"],["love",50],["pou",60] ]
for k,v in a:
    print(k,"__",v)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-29-61c9fb27ad48> in <module>()
      1 ## 双层列表循环变异
      2 a = [["one",20,"onr"],["love",50],["pou",60] ]
----> 3 for k,v in a:
      4     print(k,"__",v)

ValueError: too many values to unpack (expected 2)

In [32]:

 
 

## 双层列表循环变异
a = [["one",20,"hah"],["love",50,"yyj"],["pou",60,"bbq"] ]
# 这个例子说明，k v w 的个数应该跟解包出来的个数一致
for k,v,w in a:
    print(k,"__",v,"__",w)

one __ 20 __ hah
love __ 50 __ yyj
pou __ 60 __ bbq

 
# 列表内涵： list content
?
 - 通过简单的方式创作列表

列表内涵： list content?

通过简单的方式创作列表

In [33]:

 
 

# for 创建
a = ["a","b","c","d"]
# 用 list a 创建一个 list b 
# 下面代码的含义是，对于所有 a 中元素，这个放入新的列表中
b = [i for i in a]
print(b)

[‘a‘, ‘b‘, ‘c‘, ‘d‘]

In [34]:

 
 

# 对于 a 中所有元素乘以 10 ，生成一个新的 list 
a = ["a","b","c","d"]
# 用 list a 创建一个 list b 
# 下面代码的含义是，对于所有 a 中元素，这个放入新的列表中
b = [i*10 for i in a]
print(b)

[‘aaaaaaaaaa‘, ‘bbbbbbbbbb‘, ‘cccccccccc‘, ‘dddddddddd‘]

In [38]:

 
 

#  还可以过滤原来 list 中内容放入新的列表
#  比如原有列表 a ，需要把所有 a 中的偶数生成新的列表 b
?
a = [x for x in range(1,35)] # 生成从 1 到 34 的整数列表
# 吧 a 中所有偶数生成一个新的列表 b 
b = [m for m in a if m % 2 == 0 ]
print(b)

[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34]

In [44]:

 
 

# 列表生成可以嵌套
# 由两个列表 a ，b
?
a = [i for i in range(1,10)]# 生成列表 a 
print(a)
?
b = [i for i in range(100,400) if i % 100 == 0]
print(b)
?
# 列表生成是可以嵌套,此对等于两个 for 循环嵌套 
c = [m+n for m in a for n in b]
print(c)
?
# 上面代码跟下面的代码等价
for n in a:
    for m in b:
        print(m+n, end="   ")
print()
?
?
?
# 嵌套的列表生成式也可以用条件表达式
c = [ m+n for m in a for n in b if m+n < 200]
print(c)

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[100, 200, 300]
[101, 201, 301, 102, 202, 302, 103, 203, 303, 104, 204, 304, 105, 205, 305, 106, 206, 306, 107, 207, 307, 108, 208, 308, 109, 209, 309]
101   201   301   102   202   302   103   203   303   104   204   304   105   205   305   106   206   306   107   207   307   108   208   308   109   209   309   
[101, 102, 103, 104, 105, 106, 107, 108, 109]

 
##  关于列表的函数
?

关于列表的函数?

In [52]:

 
 

# len 求列表长度
a = [x for x in range(1,20)]
print(len(a))
?
# max :求函数中的最大值
# min: 同理(最小值)
print(max(a))
print(min(a))
?
b = ["one","whuin","lone"]
print(max(b))
print(min(b))

19
19
1
whuin
lone

In [48]:

 
# list ：把其他的数据转换成 list 
a = [1,2,3]
print(list(a))

[1, 2, 3]

In [49]:

 
s = "I am is yj do you know"
print(list(s))

[‘I‘, ‘ ‘, ‘a‘, ‘m‘, ‘ ‘, ‘i‘, ‘s‘, ‘ ‘, ‘y‘, ‘j‘, ‘ ‘, ‘d‘, ‘o‘, ‘ ‘, ‘y‘, ‘o‘, ‘u‘, ‘ ‘, ‘k‘, ‘n‘, ‘o‘, ‘w‘]

In [ ]:

print()

以上是关于内建函数与列表常用函数的主要内容，如果未能解决你的问题，请参考以下文章