当前位置: 澳门新濠3559 > 编程 > 正文

(1)列表末尾添加,它们的值可能相同

时间:2019-11-08 23:18来源:编程
1、添加元素 1、打印:print(100000) 《python基础教程》笔记之 条件语句和循环语句,python循环语句 布尔变量 下面的值会被解释器看做假(false): False None 0 "" () {} [] 其它的一切都被解释为

1、添加元素

1、打印:print(100000)

《python基础教程》笔记之 条件语句和循环语句,python循环语句

  • 布尔变量

下面的值会被解释器看做假(false):

False None 0 "" () {} []

其它的一切都被解释为真。

>>> True
True
>>> False
False
>>> True == 1
True
>>> False == 0
True
>>> True + False +42
43

bool函数 -- 用来转换其它值,如

>>> bool([])
False
>>> bool('hello,world')
True

  • 条件语句

if else elif

is 和 is not -- 判断两个变量是不是同一个对象

>>> x=y=[1,2,3]
>>> z=[1,2,3]
>>> x == y
True
>>> x == z
True
>>> x is y
True
>>> x is z
False

上例中可见,因为is运算符是判定同一性的。变量x和y都被绑定在同一个列表上,而变量z被绑定在另外一个具有相同数值和顺序的列表上。它们的值可能相同,但是却不是同一个对象。

in 和 not in -- 成员资格运算符

assert -- 当条件不为真时,程序崩溃

>>> x = 5
>>> assert 0<x<10
>>> assert 5<x <4

Traceback (most recent call last):
  File "<pyshell#25>", line 1, in <module>
    assert 5<x <4
AssertionError

  • 循环

range -- 内建范围函数,它包含下限,但不包含上限,如

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

for num in range(0, 10):
    print num,

结果如下

>>>
0 1 2 3 4 5 6 7 8 9

循环遍历字典,可以使用序列解包,如

d = {'x':1, 'y':2}
for key, value in d.items():
    print key, 'corresponds to', value

结果

>>>
y corresponds to 2
x corresponds to 1

 zip -- 可以将任意多个序列“压缩”在一起,然后返回一个元组的列表,同时他可以应付不等长的序列,当最短的序列“用完”时就会停止,如

>>> zip(range(5), xrange(10000))
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
>>> names=['a', 'b', 'c']
>>> ages = [45, 23 ,98]
>>> zip(names, ages)
[('a', 45), ('b', 23), ('c', 98)]

并行迭代,如

names=['a', 'b', 'c']
ages = [45, 23 ,98]
for name, age in zip(names, ages):
    print name, 'is', age, 'old'

结果

>>>
a is 45 old
b is 23 old
c is 98 old

编号迭代 -- 迭代序列中的对象,同时还要获取当前对象的索引,如

names=['Mr.a', 'Ms.b', 'Mr.c']
for index, name in enumerate(names):
    if 'Mr' in name:
        names[index] = 'nan'
for name in names:
    print name,

结果
>>>
nan Ms.b nan

翻转和排序迭代(sorted和reversed) -- 作用域任何序列或可迭代对象上,不是原地修改对象,而是返回翻转或排序后的版本,但是返回对象不能直接对它使用索引、分片以及调用list方法,可以使用list类型转换返回的对象,如

>>> sorted([4,3,8,6,3,])
[3, 3, 4, 6, 8]
>>> sorted('hello, world!')
[' ', '!', ',', 'd', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
>>> list(reversed('hello, world!'))
['!', 'd', 'l', 'r', 'o', 'w', ' ', ',', 'o', 'l', 'l', 'e', 'h']
>>> ''.join(reversed('hello, world!'))
'!dlrow ,olleh'

break/continue -- 跳出循环/继续下一轮循环

循环中的else子句 -- 如果循环中没有调用break时,else子句执行,如

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

结果

>>>
Didn't dind it!

  • 列表推导式--轻量级循环

列表推导式是利用其它列表创建新列表的一种方法,如

>>> [(x,y) for x in range(3) for y in range(3)]
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
>>> girls = ['alice', 'bernice', 'clarice']
>>> boys = ['chris', 'arnold', 'bob']
>>> [b+'+'+g for b in boys for g in girls if b[0] == g[0]]
['chris+clarice', 'arnold+alice', 'bob+bernice']

 

条件语句和循环语句,python循环语句 布尔变量 下面的值会被解释器看做假(false): False None 0 "" () {} [] 其它的一...

什么是列表?

(1)列表末尾添加

print("字符串输出")

列表就是可变的有序的元素集合,列表里面的每一个元素都有他的下标,其实python里面的列表就有些像java里面的数值,

x=[1,2]

2、获取输入:input("输入提示:")

列表的表现形式:从下面这个列表我们可以看出来,列表是用一对[],然后里面的类型是object,什么类型都可以,也可以嵌套列表;

x.append(3)

3、导入模块:

name=['zhangsan','lisi',18,19,True,[8,6]]

>>>x=[1,2,3]

a、import math

列表的赋值方式:上面就是一种赋值方式,直接赋值,还有一个range()函数也可以完成列表的赋值:这个函数,有3个参数,第一个参数是起始位置,然后是终点位置,最后一个是步长,也是左闭右开区间;对于range()函数,需要注意一点就是在python3里面你用到这个列表的时候才会生成,如果你没有用到这个列表是不会生成的

(2)列表中插入

这种方式使用math库中的函数方式:math.floor(3.0)

age=range(5,91,2)

x=[1,2]

b、如果不想在floor前面加上math前缀,可以用这种加载方式:from math import floor,那么上述语句可以使用:

第二种赋值方式:列表推导式,用for  in 语句,用这种方式可以把一个列表进行克隆或者是说变大或者缩小;

x.insert(1,5)# 在索引1处添加空间, 并将值5 存储到这个地方

floor(3.0)

age=[1,2,3,5,7,9,11]

age1=[num for num in age if num%2==0]

print(age1)

>>>x=[1,5,2]

4、注释:

列表的常用操作,这个对于列表来说还是比较重要的,就和之前说的字符串的常用操作一样,主要有四种常用操作:

2、删除元素

#表示单行注释

增:

(1)del语句删除

‘’‘多行注释’‘’ """多行注释"""前后都是三个单引号或者三个多引号

A:通过append()语句,用于在列表的末尾增加一个元素;

x=[1,2,3]

#coding=utf-8编码标注

age = [9]

age.append(10)

print(age)

del x[0]#

5、转义字符:‘’

B:通过insert语句,可以把一个object插入你想插入的地方;

>>>x=[2,3]

6、字符串拼接:'+'

age = [9]

age.insert(0,10)

print(age)

(2)使用pop删除

7、数字类型:

C:通过extend()语句,可以把一个列表增加多个值,但是这些值也是只能增加在最后;

可删除列表中任何一个数,并且还能继续使用它,当pop()里为空时,默认弹出列表末尾的数。

int float bool

tag=[2,8,10]

age = [9]

age.extend(tag)

print(age)

x=[1,2,3]

complex(复数),Python3中没有Long,而2中有

D:通过乘法运算和加法运算也可以把列表增加:乘法就是把自己乘多少遍,加法就是在最后连接一个列表,需要注意一点就是这两种方式不会修改原列表;

y=x.pop(1)

8、str和repr的差别:

tag='woshishui'

age = [9]

age*=5

age+=tag

print(age)

>>>x=[1,3]

str出来的值是给人看的字符串,repr出来的值是给机器看的,括号中的任何内容出来后都是在它之上再加上一层引号

删:

>>>y=2

print(str("Echo"))的结果是:'Echo'

A:pop()语句,删除对应下标值的元素;默认是-1,即最后一个元素;

(3)使用remove删除特定的值

print(repr("Echo"))的结果是:Echo

age=[1,2,3,4,5,6,7,8]

age.pop(0)

print(age)

只知道值是多少,但不知道其在列表中的索引时,可用remove()进行删除,但列表中出现多个该数时,只会删除第一个,若想要都删除,则需借助循环。

9、打印跨越多行的字符串:

B:remove()语句,删除对应的object元素,默认是移除最左边的一个object

x=[1,2,3]0

print('''多行字符串''')或者将字符串头尾的单引号改成双引号

age=[1,2,3,4,5,6,7,8]

age.remove(1)

print(age)

x.remove(3)

10、原始字符串:

C:del语句,这个就厉害了,这个会删除内存地址,即会把你的存储空间都删掉

(1)列表末尾添加,它们的值可能相同。>>>x=[1,2]

在字符串引号的前面加上一个r(和C#中的@一个意思),如:

age=[1,2,3,4,5,6,7,8]

del age

3、组织列表

print(r"第一行n第二行")因为r,在第一行和第二行之间的n就不会变成换行符

改:可以通过下标值去直接修改object,需要注意的是[]里面的值是下标值;

(1)用sort对列表进行永久性排序

不过原始字符串不能以反斜杠结尾,如果原始字符串结尾需要是一个反斜杠的话,可以使用拼接的方式:print(r"第一行n第二行" '\')

age = [1, 2, 3, 4, 5, 6, 7, 8]

age[1] = 8

print(age)

假设列表中值都是小写的,让列表按首字母顺序排列。

11、常用内建序列:列表和元组,列表可以修改,元组则不能;其他内建序列还有:字符串、Unicode字符串、buffer对象和xrange对象

查:

x=['h','c','l','p','a','d','r','g']

如下:edward john是列表,database也是列表

A:获取单个元素

x.sort()

edward = ['EdwardGumby', 42]

age = [1, 2, 3, 4, 5, 6, 7, 8]

print(age[2])

print(x)

john = ['JohnSmith', 50]

B:获取元素索引,Index()语句,第一个元素是object值,第二个元素是起始位置,第三个元素是终点位置;

>>>['a', 'c', 'd', 'g', 'h', 'l', 'p', 'r']

database =[edward,john, 1]

age = [1, 2, 3, 4, 5, 6, 7, 8,2,8,2]

print(age.index(2,-2))

按照与字母相反的顺序排列,向sort传递reverse=True.

print(database)

C:获取指定元素个数:count()

x=['h','c','l','p','a','d','r','g']

print(database[0])

age = [1, 2, 3, 4, 5, 6, 7, 8,2,8,2]

print(age.count(2))

x.sort(reverse=True)

print(edward[-1])

D:切片,就和string一个形式,第一个参数是起始位置,第二个参数是终点位置,第三个参数是步长,需要注意一点就是中间是用:间隔符;如果步长是负数,就是从最后一个开始往前面取值,

print(x)

输出结果:

age = [1, 2, 3, 4, 5, 6, 7, 8, 2, 8, 2]

print(age[1:8: 2])

>>>['r', 'p', 'l', 'h', 'g', 'd', 'c', 'a']

序列中的元素都是有编号的,从0开始递增,因此可以用下标访问,如上,database[0]。下标-1表示从尾部开始

E:反转[::-1]

(2)用sorted对列表进行临时排序。

12、序列的分片,冒号分割,做闭包,左边位置包括,右边位置不包括:

age = [1, 2, 3, 4, 5, 6, 7, 8, 2, 8, 2]

print(age[:: -1])

需要临时以特定的顺序呈现列表 ,但又要保留列表一开始的顺序,可用sorted().若需要按与字母顺序相反的方式显示列表,也可向函数sorted传递参数reverse=True.

tag="0123456789"

F:遍历

x=['h','c','l','p','a','d','r','g']

print(tag[2:3]) #2

F.1通过元素进行遍历:

print(sorted(x))

print(tag[2:-1])#2345678

age = ['a','v','f','g','s','w']

for v in age:

    print(v)

print(x)

print(tag[-3:-1])#78

F.2通过索引进行遍历:首先应该得到元素的索引,然后通过索引就能拿到元素的值了:

>>>['a', 'c', 'd', 'g', 'h', 'l', 'p', 'r']

print(tag[0:])#0123456789

age = ['a','v','f','g','s','w']

indexs=range(len(age))

for v in indexs:

    print(age[v])

['h', 'c', 'l', 'p', 'a', 'd', 'r', 'g']

print(tag[:])#0123456789

F.3通过枚举对象遍历:通过枚举函数,将一个可遍历的对象生成一个新的对象,这个对象的每一个元素都包含之前对象的下标和对应值;由于枚举对象的每一个元素都是一个元祖对象,所以也可以这样写 a,b

(3)反转列表

print(tag[-3:0]) #空 无效

age = ['a','v','f','g','s','w']                            

enum =enumerate(age)

for e in enum:

    print(e)

age = ['a','v','f','g','s','w']

enum =enumerate(age)

for a,b in enum:

    print(a,b)

对列表顺序进行反转,可用方法reverse(),以上两个排序都提到了reverse,但reverse并不是按字母顺序反转列表元素,而仅仅是将列表元素排列顺序反转。

print(tag[::2])

F.4通过迭代器进行遍历:在讲通过迭代器进行遍历之前,需要讲两个概念一个就是可迭代对象,一个是迭代器,可迭代对象实际上就是指这个对象拥有遍历的这个属性,可以使用for in进行遍历,那么这个对象就是可迭代对象,另外一个使用一个函数进行验证,isinstance,这个函数相当于是判断这个对象是否拥有这个能力,

x=['h','c','l','p','a','d','r','g']

#02468第三个参数表示步长,如前面几行没设置就是默认1

判断是否可迭代

import collections

age = ['a','v','f','g','s','w']

result=isinstance(age,collections.Iterable)

print(result)

x.reverse()

print(tag[::-2])

那么什么又是迭代器呢,迭代器是可以记录遍历位置的对象,也就是说你把一个列表转成迭代器之后,迭代器本身就拥有了遍历的能力了,也就是可以自己完成遍历了,当然迭代器也是可迭代对象,所以自然也可以用for in 语句,把一个可迭代对象转成迭代器使用:iter()函数;判断是否是迭代器也有两种方式,第一就是可不可以自己完成遍历过程,也就是调用next()函数,第二也是用isinstance函数,

print(x)

#97531步长是负数,从右向左提取

it=iter(age)

result=isinstance(it,collections.Iterator)

next(it)

print(result)

===========================

it=iter(age)

result=isinstance(it,collections.Iterator)

next(it) for i in it:

    print(i)

print(result)

>>>['g', 'r', 'd', 'a', 'p', 'l', 'c', 'h']

print(tag[2:8:-2])

迭代器的优点:节约内存空间,他只有一个内存地址保存当前遍历到的对象,这之前,之后的对象都没有分配内存地址,也提供了统一的针对可迭代对象进行遍历的接口;需要注意一点是迭代器只能迭代一次,不能多次使用;

(4)列表长度

#无效 步长是负数,起始点索引必须大于结束点索引

G:判定,判断一个元素是否在一个集合里面,用in  not in语句;

查看列表长度,使用方法len()

print(tag[8:2:-2])#864

age = ['a','v','f','g','s','w']

newStr='a'

newStr1='l'

result=newStr in age

result1=newStr1 not in age

print(result,result1)

x=['h','c','l','p','a','d','r','g']

print(tag[2::-2])

H:比较,对于比较的话,python2用的是cmp()函数,而python3用的是比较符:> < ==

len(x)

#20第二个位置开始往左边按照步长2分片

H.1 python3:

>>>8

13、序列成员资格检查in,检查一个值是否在序列中,使用in运算符

list = [1, 9, 6]

list1 = [1, 8, 7]

resule = list > list1

print(resule)

4、操作列表

permissions ='rwx'

H.2 python2

(1)for循环遍历列表

print('x'inpermissions) #True

list = [1, 9, 6]

list1 = [1, 8, 7]

result=cmp(list1,list)

print(result)

依次遍历x中元素,i的名称可自己定义,但最好有意义,如for cat in cats,这样便于理解。

print("a"in permissions) #False

I.排序,有两种方式,一种就是用内建函数,sorted,第二种用列表对象方法,list.sort()两种方法都是大同小异,先说第一种:

x=['h','c','l','p','a','d']

print("rw"in permissions) #True

list=['k','a','s','w','j']

result=sorted(list,reverse=True)

print(result)

for i in x:

14、序列的长度、最小值和最大值:len、min、max

reverse控制的是增序,还是降序,默认是增序,设置为True就是降序;还有一种情况就是指定排序的元素,比如:这种情况就针对一个元素有多个值得情况,我们可以让它对哪个进行排序;

    print(i)

15、列表的基本操作:

list=[('n',5),('w',8),('h',9),('t',1),('b',3),('l',7)]

def getkey(x):

    return x[1]

result=sorted(list,key=getkey)

print(result)

>>>h

可以用字符串创建列表:print(list("Perl"))#['P','e','r','l']

list.sort()方法,是针对于列表本身得,所以通过这种方式改变得是列表本身,也并没有返回值,sorted方法呢,是内建函数,他不会改变列表本身,只会将列表排好序之后返回出来;

c

元素赋值:x[1]=2,改变x列表第2个位置的值,不能为一个位置不存在的元素进行赋值

J:乱序,就是把列表得顺序打乱,通过得是random得shuffle()函数,打乱得是列表本身

l

删除元素:del

list=[('n',5),('w',8),('h',9),('t',1),('b',3),('l',7)]

random.shuffle(list)

print(list)

p

x[1],删除列表第2个位置的元素,并且列表长度-1

K:反转,两种方式,一种是直接调用:reverse(),这种方式反转得是列表自己,另一种用切片反转;这种方式,列表不会改变:

a

分片赋值:

list.reverse()

res=list[::-1]

d

perl =list("Perl")

好了 ,列表所有操作结束了;

(2)创建数值列表

print(perl)#['P','e','r','l']

先使用range()生成数字集,再利用list()将数字集转化为列表。

perl[1] = 'a'

x=list(range(1,5))

print(perl)#['P','a','r','l']

print(x)

del perl[1]

>>>[1,2,3,4]

print(perl)#['P','r','l']

range()还可以定制步长,设定好起始数及终止数,再加入步长,如range(2,16,3)

perl[1:1] = 'ffff'

list(range(2,16,3))

#['P','f','f','f','f','r','l']如果起始点和结束点位置一样,则做插入

>>>[2, 5, 8, 11, 14]

print(perl)

(3)列表解析

perl[1:3] = 'gggg'

列表解析可让for循环一行代码写完。

#['P','g','g','g','g','f','f','r','l']如果起始点和结束点之间的位置不够放右值,则替换掉已有的位置值,剩余的值做插入处理

x=[i**2 for i in range(1,11)]

print(perl)

print(x)

perl[1:8:2] =

>>>[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

'hhhh' #['P','h','g','h','g','h','f','h','l']如果步长大于1,那么右值的个数要等于分片数,否则编译不通过

其中i**2表示列表值的表达式,后面的语句将1~10传递给表达式 ,这里的for循环不需要冒号。

print(perl)

(4)切片

16、 列表方法

需指定第一个元素及最后一个元素的索引,若第一个索引为空时,默认从列表开头获取,同理,若第二个索引为空,默认提取到列表末尾。

append,在列表末尾追加新对象x.append(1)

x=['h','c','l','p','a','d']

count,计算某个元素在列表中出现的次数:x.count(1)

print(x[1:4])

extend,在列表的末尾一次性追加另一个序列的多个值,通过修改原始序列,而“+”连接操作符是返回一个全新的列表

print(x[:4])

index,从列表中找出某个值第一个匹配项的索引,但是如果索引的值不存在,会产生异常

>>>['c', 'l', 'p']

insert,将对象插入列表,x.insert(1,'dkjf')

['h', 'c', 'l', 'p']

pop,一处列表中的一个元素,默认最后一个,并返回该元素的值

(5)复制切片

remove,用于移除列表中某个值的第一个匹配项,在原有列表上修改

当需要对列表进行复制时,需要进行切片复制,直接赋值是行不通的。

reverse,将列表中的元素反向存放,在原有列表上修改

x=[1,2,3,4,5,6]

sort,排序列表,在原有列表上修改,返回一个空值,如果想保存排序前的x列表,那么在排序前保存x列表的副本,保存x列表副本的方式:

y=x

y=x[:] y.sort()用副本y排序

z=x[:]

y=sorted(x)这个函数可以用于任何序列,但是总是返回一个列表

x.append(7)

y=x错误的使用方式,这条语句是将x y指向同一个副本

print(x)

高级排序

print(y)

x.sort(cmp) #cmp制定排序函数

print(z)

x.sort(key=len) #按长度排序

>>>[1, 2, 3, 4, 5, 6, 7]

x.sort(reverse=True)

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

#反向排序

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

17、元组,不能修改的序列,列表用中括号,元组用圆括号,单个元素的元组,要在元素后面加一个逗号,如(1,),因为如果不加逗号会被认为是数字

从结果可以看出,y跟着x进行了变化,只有z才是真正复制了一个列表。

tuple([1,2,3]) #把list转换成元组

 

tuple('abc')==》('a','b','c')

 

序列的操作函数元组都有,但是列表的没有哦

 

18、字符串,字符串是不能修改的序列

 

格式化:

 

format ="Hello %s %d %%"

 

values =("wff", 10)

print(format%values)#Hello wff 10 %

格式化字符串里如果要显示%就得用‘%%’

模板字符串:

字符串函数:

find,查找子字符串,返回字符串所在位置,不存在返回-1。str.find('aaa')

join,是split方法的逆方法,将队列拼成字符串,可以带拼接符。

lst=['1','2']

sep='+'

newlst=sep.join(lst)

print(newlst) #1+2

lower,返回字符串的小写字母版,str.lower()

replace,字符串替换,

split

strip去除字符串两侧的空格

translate

maketrans(这个函数3.5之后现在在str类中)

x='this!is!'

a=str.maketrans('','',string.punctuation)

x=x.translate(a)

#结果:thisis字符串x中的punctuation将会被替换成空

print(x)

s='abcdefab'

table=str.maketrans('ab','AB')

s=s.translate(table)

#结果:ABcdefAB将s列表中的ab替换成AB

print(s)

19、字典

创建:

items =[('name','Gumby'),('age',42)] d = dict(items)

d=dict(name='Gumby',age=42)

访问方式和正常的字典一样

来一点特别的,字典的格式化字符串,非常给力:

fmt ="name:%(name)s,age:%(age)s"

print(fmt%d)#name:Gumby,age:42

字典方法:

clear

copy,返回一个具有相同键-值对的新字典(浅复制),如果想深复制,可以使用copy.deepcopy(dic)

fromkeys,使用给定的键建立新字典:

t={}.fromkeys(['name','age'],

'unknow') #如果没有提供默认值,则默认为None

get:

print(d.get('sex',

'unknow')) #sex不存在则返回unknow,如果没设置unknown,则sex不存在的情况抛出异常

items和iteritems,items是以列表的顺序返回所有所有键值对

keys和iterkeys

pop:d.pop('age')将age键值对从字典中移除,等于remove

popitem:弹出随机的一个键值对

update:利用一个字典项去更新另一个字典

d.update(x)用x字典中的项去更新d字典,不存在的新增,存在的则覆盖

values和itervalues

20、日志输出,print和logging,后者有分日志等级logging.info/warning/error等

21、import

import math

from math importsqrt,pow,add

from math importsqrtas foobar

import math asmymath

22、if语句

以下值当做布尔表达式的时候被认为是假:

False None 0"" () {} []

其他为真

if else elif

22、语句块,以“:”(冒号)开始,缩进改变为结束

23、字母的顺序值,ord函数,还有一个chr函数功能相反

print ord('a') #97

print chr(97) #a

24、三目运算符:print(11 if True else 22)#11

25、range函数,range(0,10)

#0123456789左闭包

xrange函数,xrange(1,5),生成一个生成器,每次加1

26、for语句

for word in words:

for num inrange(0,10):

for key,values ind.items:

27、while语句

while True:

28、zip函数

for name,age in

zip(names,ages): #names/ages分别是一个List

zip(range(5),xrange(10000))

#zip可以处理不等长序列,短序列处理完就停止。

29、enumerate函数,返回序列的索引-值对

for index,stringin enumerate(strings):

if 'xxx' instring:

strings[index]='newval'

30、reversed和sorted,返回翻转或者排序后的版本。

31、跳出循环,break、continue

32、列表推导式---轻量级循环

print([x*x for xin range(10) if x%3==0]) #0,9,36,81

for循环中的元素,满足是3的倍数,则将其平方返回。x%3可以换成其他的条件

print([(x,y) for x

in range(3) for y in range(3)]) #结果为x012和y012的排列组合

33、空代码块,pass

34、删除对象

x=None

或者del x

35、动态执行Python代码,exec

scope={} #命名空间,将代码放在命名空间中执行

exec("print('Hello,World')") in scope#Hello,World

36、动态执行表达式:eval以下是加了作用于的eval

scope = {}

scope['x'] = 2

scope['y'] = 3

print(eval('x*y',scope)) #6

37、

编辑:编程 本文来源:(1)列表末尾添加,它们的值可能相同

关键词: