首页 飞桨领航团 帖子详情
【AI达人养成营】学习笔记--是杨十啊
收藏
快速回复
飞桨领航团 文章AI达人创造营 884 0
【AI达人养成营】学习笔记--是杨十啊
收藏
快速回复
飞桨领航团 文章AI达人创造营 884 0

List

第一个办法是用 list 的 append() 方法,把新同学追加到 list 的末尾:
>>> L = ['Adam', 'Lisa', 'Bart'] >>> L.append('Paul') >>> print L ['Adam', 'Lisa', 'Bart', 'Paul']
append()总是把新的元素添加到 list 的尾部。
方法是用list的 insert()方法,它接受两个参数,第一个参数是索引号,第二个参数是待添加的新元素:
>>> L = ['Adam', 'Lisa', 'Bart'] >>> L.insert(0, 'Paul') >>> print L ['Paul', 'Adam', 'Lisa', 'Bart']
L.insert(0, 'Paul') 的意思是,'Paul'将被添加到索引为 0 的位置上(也就是第一个),而原来索引为 0 的Adam同学,以及后面的所有同学,都自动向后移动一位。


如果Paul同学排在最后一个,我们可以用list的pop()方法删除:
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul'] >>> L.pop() 'Paul' >>> print L ['Adam', 'Lisa', 'Bart']
pop()方法总是删掉list的最后一个元素,并且它还返回这个元素,所以我们执行 L.pop() 后,会打印出 'Paul'。
>>> L = ['Adam', 'Lisa', 'Paul', 'Bart']
要把Paul踢出list,我们就必须先定位Paul的位置。由于Paul的索引是2,因此,用 pop(2)把Paul删掉:
>>> L.pop(2) 'Paul' >>> print L ['Adam', 'Lisa', 'Bart']


tuple
是另一种有序的列表,中文翻译为“ 元组 ”。tuple 和 list 非常类似,但是,tuple一旦创建完毕,就不能修改了。
同样是表示班里同学的名称,用tuple表示如下:
>>> t = ('Adam', 'Lisa', 'Bart')
创建tuple和创建list唯一不同之处是用( )替代了[ ]。
现在,这个 t 就不能改变了,tuple没有 append()方法,也没有insert()和pop()方法。所以,新同学没法直接往 tuple 中添加,老同学想退出 tuple 也不行。
获取 tuple 元素的方式和 list 是一模一样的,我们可以正常使用 t[0],t[-1]等索引方式访问元素,但是不能赋值成别的元素,
tuple和list一样,可以包含 0 个、1个和任意多个元素。
包含多个元素的 tuple,前面我们已经创建过了。
包含 0 个元素的 tuple,也就是空tuple,直接用 ()表示:
>>> t = () >>> print t ()
因为()既可以表示tuple,又可以作为括号表示运算时的优先级,结果 (1) 被Python解释器计算出结果 1,导致我们得到的不是tuple,而是整数 1。
正是因为用()定义单元素的tuple有歧义,所以 Python 规定,单元素 tuple 要多加一个逗号“,”,这样就避免了歧义:
>>> t = (1,) >>> print t (1,)
Python在打印单元素tuple时,也自动添加了一个“,”,为了更明确地告诉你这是一个tuple。
多元素 tuple 加不加这个额外的“,”效果是一样的:
>>> t = (1, 2, 3,) >>> print t (1, 2, 3)
可变”的tuple:
>>> t = ('a', 'b', ['A', 'B'])
注意到 t 有 3 个元素:'a','b'和一个list:['A', 'B']。list作为一个整体是tuple的第3个元素。list对象可以通过 t[2] 拿到:
>>> L = t[2]
然后,我们把list的两个元素改一改:
>>> L[0] = 'X' >>> L[1] = 'Y'
再看看tuple的内容:
>>> print t ('a', 'b', ['X', 'Y'])
不是说tuple一旦定义后就不可变了吗?怎么现在又变了?
别急,我们先看看定义的时候tuple包含的3个元素:

当我们把list的元素'A'和'B'修改为'X'和'Y'后,tuple变为:

表面上看,tuple的元素确实变了,但其实变的不是 tuple 的元素,而是list的元素。
输入用户年龄,根据年龄打印不同的内容,在Python程序中,可以用if语句实现:
age = 20 if age >= 18: print 'your age is', age print 'adult' print 'END'
注意: Python代码的缩进规则。具有相同缩进的代码被视为代码块,上面的3,4行 print 语句就构成一个代码块(但不包括第5行的print)。如果 if 语句判断为 True,就会执行这个代码块。
缩进请严格按照Python的习惯写法:4个空格,不要使用Tab,更不要混合Tab和空格,否则很容易造成因为缩进引起的语法错误。
注意: if 语句后接表达式,然后用:表示代码块开始。
如果你在Python交互环境下敲代码,还要特别留意缩进,并且退出缩进需要多敲一行回车:
>>> age = 20 >>> if age >= 18: ... print 'your age is', age ... print 'adult' ... your age is 20 adult
if-elif-else
if age >=18: print .... elif age >=123 ....
for循环 continue
L=[a,b,c,d]; for name in L: print name continue
While 循环 break
N=10 while N>1 : print m break

 



无序性:

更新dict



dict的作用是建立一组 key 和一组 value 的映射关系,dict的key是不能重复的。
有的时候,我们只想要 dict 的 key,不关心 key 对应的 value,目的就是保证这个集合的元素不会重复,这时,set就派上用场了。
set 持有一系列元素,这一点和 list 很像,但是set的元素没有重复,而且是无序的,这点和 dict 的 key很像。
创建 set 的方式是调用 set() 并传入一个 list,list的元素将作为set的元素:
>>> s = set(['A', 'B', 'C']) 可以查看 set 的内容:
>>> print s set(['A', 'C', 'B'])
请注意,上述打印的形式类似 list, 但它不是 list,仔细看还可以发现,打印的顺序和原始 list 的顺序有可能是不同的,因为set内部存储的元素是无序的。
因为set不能包含重复的元素(重要作用:去除重复的元素),所以,当我们传入包含重复元素的 list 会怎么样呢?
>>> s = set(['A', 'B', 'C', 'C']) >>> print s set(['A', 'C', 'B']) >>> len(s) 3
结果显示,set会自动去掉重复的元素,原来的list有4个元素,但set只有3个元素。
由于set存储的是无序集合,所以我们没法通过索引来访问。
访问 set中的某个元素实际上就是判断一个元素是否在set中。
例如,存储了班里同学名字的set:
>>> s = set(['Adam', 'Lisa', 'Bart', 'Paul'])
我们可以用 in 操作符判断:
Bart是该班的同学吗?
>>> 'Bart' in s True
Bill是该班的同学吗?
>>> 'Bill' in s False
bart是该班的同学吗?
>>> 'bart' in s False
看来大小写很重要,'Bart' 和 'bart'被认为是两个不同的元素。


如果事先创建好一个set,包含'MON' ~ 'SUN':
weekdays = set(['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN'])
再判断输入是否有效,只需要判断该字符串是否在set中:
x = '???' # 用户输入的字符串 if x in weekdays: print 'input ok' else: print 'input error'
一是把新的元素添加到set中,二是把已有元素从set中删除。
添加元素时,用set的add()方法:
>>> s = set([1, 2, 3]) >>> s.add(4) >>> print s set([1, 2, 3, 4])
如果添加的元素已经存在于set中,add()不会报错,但是不会加进去了:
>>> s = set([1, 2, 3]) >>> s.add(3) >>> print s set([1, 2, 3])
删除set中的元素时,用set的remove()方法:
>>> s = set([1, 2, 3, 4]) >>> s.remove(4) >>> print s set([1, 2, 3])
如果删除的元素不存在set中,remove()会报错:
Python内置了很多有用的函数,我们可以直接调用。
要调用一个函数,需要知道函数的名称和参数,比如求绝对值的函数 abs,它接收一个参数。
可以直接从Python的官方网站查看文档: http://docs.python.org/2/library/functions.html#abs
也可以在交互式命令行通过 help(abs) 查看abs函数的帮助信息。
调用 abs 函数:
>>> abs(100) 100 >>> abs(-20) 20 >>> abs(12.34) 12.34
调用函数的时候,如果传入的参数数量不对,会报TypeError的错误,并且Python会明确地告诉你:abs()有且仅有1个参数,但给出了两个:
>>> abs(1, 2) Traceback (most recent call last): File "", line 1, in TypeError: abs() takes exactly one argument (2 given)
如果传入的参数数量是对的,但参数类型不能被函数所接受,也会报TypeError的错误,并且给出错误信息:str是错误的参数类型:
>>> abs('a') Traceback (most recent call last): File "", line 1, in TypeError: bad operand type for abs(): 'str'
而比较函数 cmp(x, y) 就需要两个参数,如果 xy,返回 1:
>>> cmp(1, 2) -1 >>> cmp(2, 1) 1 >>> cmp(3, 3) 0
Python内置的常用函数还包括数据类型转换函数,比如   int()函数可以把其他数据类型转换为整数:
>>> int('123') 123 >>> int(12.34) 12
str()函数把其他类型转换成 str:
>>> str(123) '123' >>> str(1.23) '1.23'
在Python中,定义一个函数要使用 def 语句,依次写出函数名、括号、括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用 return 语句返回。
我们以自定义一个求绝对值的 my_abs 函数为例:
def my_abs(x): if x >= 0: return x else: return -x
请注意,函数体内部的语句在执行时,一旦执行到return时,函数就执行完毕,并将结果返回。因此,函数内部通过条件判断和循环可以实现非常复杂的逻辑。
如果没有return语句,函数执行完毕后也会返回结果,只是结果为 None。
return None可以简写为return。
# math包提供了sin()和 cos()函数,我们先用import引用它:
import math def move(x, y, step, angle): nx = x + step * math.cos(angle) ny = y - step * math.sin(angle) return nx, ny
这样我们就可以同时获得返回值:
>>> x, y = move(100, 100, 60, math.pi / 6) >>> print x, y 151.961524227 70.0
但其实这只是一种假象,Python函数返回的仍然是单一值:
>>> r = move(100, 100, 60, math.pi / 6) >>> print r (151.96152422706632, 70.0)
用print打印返回结果,原来返回值是一个tuple!
但是,在语法上,返回一个tuple可以省略括号,而多个变量可以同时接收一个tuple,按位置赋给对应的值,所以,Python的函数返回多值其实就是返回一个tuple,但写起来更方便。
Python之递归函数
fact(n) = n! = 1 * 2 * 3 * ... * (n-1) * n = (n-1)! * n = fact(n-1) * n
fact(n)可以表示为 n * fact(n-1),只有n=1时需要特殊处理。
于是,fact(n)用递归的方式写出来就是:
def fact(n): if n==1: return 1 return n * fact(n - 1)
递归函数的优点是定义简单,逻辑清晰。理论上,所有的递归函数都可以写成循环的方式,但循环的逻辑不如递归清晰。
使用递归函数需要注意防止栈溢出。在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出。可以试试计算 fact(10000)。
Python之定义默认参数
计算平方的次数最多,我们就可以把 n 的默认值设定为 2:
def power(x, n=2): s = 1 while n > 0: n = n - 1 s = s * x return s
这样一来,计算平方就不需要传入两个参数了:
>>> power(5) 25
由于函数的参数按从左到右的顺序匹配,所以默认参数只能定义在必需参数的后面:
# OK: def fn1(a, b=1, c=2): pass # Error: def fn2(a=1, b): pass
Python之定义可变参数
如果想让一个函数能接受任意个参数,我们就可以定义一个可变参数:
def fn(*args): print args
可变参数的名字前面有个 * 号,我们可以传入0个、1个或多个参数给可变参数:
>>> fn() () >>> fn('a') ('a',) >>> fn('a', 'b') ('a', 'b') >>> fn('a', 'b', 'c') ('a', 'b', 'c')
可变参数也不是很神秘,Python解释器会把传入的一组参数组装成一个tuple传递给可变参数,因此,在函数内部,直接把变量 args 看成一个 tuple 就好了。
定义可变参数的目的也是为了简化调用。假设我们要计算任意个数的平均值,就可以定义一个可变参数:
def average(*args): ...
这样,在调用的时候,可以这样写:
>>> average() 0 >>> average(1, 2) 1.5 >>> average(1, 2, 2, 3, 4) 2.4
可变参数 args 是一个tuple,当0个参数传入时,args是一个空tuple。
参考代码:
def average(*args): sum = 0.0 if len(args) == 0: return sum for x in args: sum = sum + x return sum / len(args) print average() print average(1, 2) print average(1, 2, 2, 3, 4)
切片操作:
取前3个元素,用一行代码就可以完成切片:
>>> L[0:3] ['Adam', 'Lisa', 'Bart']
L[0:3]表示,从索引0开始取,直到索引3为止,但不包括索引3。即索引0,1,2,正好是3个元素。
如果第一个索引是0,还可以省略:
>>> L[:3] ['Adam', 'Lisa', 'Bart']
也可以从索引1开始,取出2个元素出来:
>>> L[1:3] ['Lisa', 'Bart']
只用一个 : ,表示从头到尾:
>>> L[:] ['Adam', 'Lisa', 'Bart', 'Paul']
因此,L[:]实际上复制出了一个新list。
切片操作还可以指定第三个参数:
>>> L[::2] ['Adam', 'Bart']
第三个参数表示每N个取一个,上面的 L[::2] 会每两个元素取出一个来,也就是隔一个取一个。
把list换成tuple,切片操作完全相同,只是切片的结果也变成了tuple。
倒序切片
对于list,既然Python支持L[-1]取倒数第一个元素,那么它同样支持倒数切片,试试:
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul'] >>> L[-2:] ['Bart', 'Paul'] >>> L[:-2] ['Adam', 'Lisa'] >>> L[-3:-1] ['Lisa', 'Bart'] >>> L[-4:-1:2] ['Adam', 'Bart']
记住倒数第一个元素的索引是-1。倒序切片包含起始索引,不包含结束索引。
字符串 'xxx'和 Unicode字符串 u'xxx'也可以看成是一种list,每个元素就是一个字符。因此,字符串也可以用切片操作,只是操作结果仍是字符串:
>>> 'ABCDEFG'[:3] 'ABC' >>> 'ABCDEFG'[-3:] 'EFG' >>> 'ABCDEFG'[::2] 'ACEG'
迭代
因为 Python 的 for循环不仅可以用在list或tuple上,还可以作用在其他任何可迭代对象上。
因此,迭代操作就是对于一个集合,无论该集合是有序还是无序,我们用 for 循环总是可以依次取出集合的每一个元素。
注意: 集合是指包含一组元素的数据结构,我们已经介绍的包括: 1. 有序集合:list,tuple,str和unicode; 2. 无序集合:set 3. 无序集合并且具有 key-value 对:dict
而迭代是一个动词,它指的是一种操作,在Python中,就是 for 循环。
迭代与按下标访问数组最大的不同是,后者是一种具体的迭代实现方式,而前者只关心迭代结果,根本不关心迭代内部是如何实现的。
用range(1, 101)可以创建数组。
参考代码:
for i in range(1, 101): if i % 7 == 0: print i
索引
enumerate() 函数:
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul'] >>> for index, name in enumerate(L): ... print index, '-', name ... 0 - Adam 1 - Lisa 2 - Bart 3 - Paul
使用 enumerate() 函数,我们可以在for循环中同时绑定索引index和元素name。但是,这不是 enumerate() 的特殊语法。实际上,enumerate() 函数把:
['Adam', 'Lisa', 'Bart', 'Paul']
变成了类似:
[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]
因此,迭代的每一个元素实际上是一个tuple:
for t in enumerate(L): index = t[0] name = t[1] print index, '-', name
如果我们知道每个tuple元素都包含两个元素,for循环又可以进一步简写为:
for index, name in enumerate(L): print index, '-', name
这样不但代码更简单,而且还少了两条赋值语句。
可见,索引迭代也不是真的按索引访问,而是由 enumerate() 函数自动把每个元素变成 (index, element) 这样的tuple,再迭代,就同时获得了索引和元素本身。
zip()函数可以把两个 list 变成一个 list:
>>> zip([10, 20, 30], ['A', 'B', 'C']) [(10, 'A'), (20, 'B'), (30, 'C')]


L = ['Adam', 'Lisa', 'Bart', 'Paul'] for index, name in zip(range(1, len(L)+1), L): print index, '-', name
如果我们希望迭代 dict 对象的value,应该怎么做?
dict 对象有一个 values() 方法,这个方法把dict转换成一个包含所有value的list,这样,我们迭代的就是 dict的每一个 value:
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 } print d.values() # [85, 95, 59] for v in d.values(): print v # 85 # 95 # 59
如果仔细阅读Python的文档,还可以发现,dict除了values()方法外,还有一个 itervalues() 方法,用 itervalues() 方法替代 values() 方法,迭代效果完全一样:
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 } print d.itervalues() # for v in d.itervalues(): print v # 85 # 95 # 59
那这两个方法有何不同之处呢?
1. values() 方法实际上把一个 dict 转换成了包含 value 的list。
2. 但是 itervalues() 方法不会转换,它会在迭代过程中依次从 dict 中取出 value,所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。
3. 打印 itervalues() 发现它返回一个 对象,这说明在Python中,for 循环可作用的迭代对象远不止 list,tuple,str,unicode,dict等,任何可迭代对象都可以作用于for循环,而内部如何迭代我们通常并不用关心。
如果一个对象说自己可迭代,那我们就直接用 for 循环去迭代它,可见,迭代是一种抽象的数据操作,它不对迭代对象内部的数据有任何要求。
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 } sum = 0.0 for v in d.itervalues(): sum = sum + v print sum / len(d)
items()
dict 对象的 items() 方法返回的值:
>>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 } >>> print d.items() [('Lisa', 85), ('Adam', 95), ('Bart', 59)]
可以看到,items() 方法把dict对象转换成了包含tuple的list,我们对这个list进行迭代,可以同时获得key和value:
>>> for key, value in d.items(): ... print key, ':', value ... Lisa : 85 Adam : 95 Bart : 59
和 values() 有一个 itervalues() 类似, items() 也有一个对应的 iteritems(),iteritems() 不把dict转换成list,而是在迭代过程中不断给出 tuple,所以, iteritems() 不占用额外的内存。
生成列表
要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],我们可以用range(1, 11):
>>> range(1, 11) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
但如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎么做?方法一是循环:
>>> L = [] >>> for x in range(1, 11): ... L.append(x * x) ... >>> L [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
但是循环太繁琐,而列表生成式则可以用一行语句代替循环生成上面的list:
>>> [x * x for x in range(1, 11)] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
这种写法就是Python特有的列表生成式。利用列表生成式,可以以非常简洁的代码生成 list。
写列表生成式时,把要生成的元素 x * x 放到前面,后面跟 for 循环,就可以把list创建出来

0
收藏
回复
在@后输入用户全名并按空格结束,可艾特全站任一用户