Python 入门学习

Posted 2020-12-29 暴走的二萌

2.3 list和tuple
list

• 可变长的集合：增加和删除元素
• len(list)
• list[0] / list[-1] ：索引访问元素

1 classmate = [‘niu‘,‘meng‘,‘hello world‘] # 中括号表示
2 classmate.append(‘the end‘)
3 classmate.pop()
4 classmate.insert(i,‘insert‘)
5 classmate[0] = ‘change‘
6 classmate = [] len(classmate)=0

 

tuple

• 不可变的有序列表，没有insert和append方法
• tuple元祖的指向永远是不变的，但是如果tuple的一个元素是list，那么可以修改list中的值来修改tuple。

1 tuple = (‘hello‘,‘world‘)

 

2.4 条件判断和循环
条件判断

1 if <条件判断1>:
2     <执行1>
3 elif <条件判断2>:
4     <执行2>
5 elif <条件判断3>:
6     <执行3>
7 else:
8     <执行4>

 

循环

1 sum = 0
2 for x in range(101):
3     sum = sum + x
4 print sum

 

2.5 dict和set的使用
dict

• 字典即为所谓的key-value键值对嘛

1 >>> d = {‘Michael‘: 95, ‘Bob‘: 75, ‘Tracy‘: 85}
2 >>> d[‘Michael‘]

 

• 注意啦注意啦！写脚本的时候查找mongodb总是报这个错误呢，一开始不明白，后来才发现是没有该字段名。MongoDB的文档，本质上是个dict。

1 >>> d[‘Thomas‘]
2 Traceback (most recent call last):
3   File "<stdin>", line 1, in <module>
4 KeyError: ‘Thomas‘

 

判断key是否存在的方法：

1 >>> ‘Thomas‘ in d
2 False

 

 

1. 通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value：

1 >>> d.get(‘Thomas‘)
2 >>> d.get(‘Thomas‘, -1)
3 -1

 

• 要删除一个key，用pop(key)方法，对应的value也会从dict中删除：

• 1 >>> d.pop(‘Bob‘)

   

  key 必须为不可变对象，如字符串；而list则不能作为key

set

• set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

 1 >>> s = set([1, 2, 3])
 2 >>> s
 3 set([1, 2, 3])
 4 >>> s.add(4) 集合增加一个元素
 5 >>>> s.remove(4) 删除一个元素 
 6 
 7 >>> s1 = set([1, 2, 3])
 8 >>> s2 = set([2, 3, 4])
 9 >>> s1 & s2 求两个集合的交集
10 set([2, 3])
11 >>> s1 | s2
12 set([1, 2, 3, 4])

 

不可变对象

 1 可变对象list:
 2 >>> a = [‘c‘, ‘b‘, ‘a‘]
 3 >>> a.sort()
 4 >>> a
 5 [‘a‘, ‘b‘, ‘c‘]
 6 
 7 不可变对象：str
 8 >>> a = ‘abc‘
 9 >>> a.replace(‘a‘, ‘A‘)
10 ‘Abc‘
11 >>> a
12 ‘abc‘
13 字符串本身并没有改变

 

三、函数

3.2 定义函数

函数的定义格式

1 def my_abs(x):
2     if x >= 0:
3         return x
4     else:
5         return -x
6 空函数

 

• pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。

1 def nop():
2     pass

 

函数多返回值

• 在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。

1 def move(x, y, step, angle=0):
2     nx = x + step * math.cos(angle)
3     ny = y - step * math.sin(angle)
4     return nx, ny
5 
6 >>> r = move(100, 100, 60, math.pi / 6)
7 >>> print r
8 (151.96152422706632, 70.0)

 

3.3 函数的参数
默认参数

• 默认参数： def enroll(name, gender, age=6, city=‘Beijing‘):
• 必选参数在前，默认参数在后，否则Python的解释器会报错
• 默认参数的一个巨大的坑：默认参数必须指向不变变量，不能指向list

可变参数

1 def calc(*numbers):
2     sum = 0
3     for n in numbers:
4         sum = sum + n * n
5     return sum

 

• 在参数numbers前面加了一个*，在函数内部，参数numbers收到的是一个tuple,可传入0-人一个参数。

关键字参数

• 如何传入一个dict

1 def person(name, age, **kw):
2     print ‘name:‘, name, ‘age:‘, age, ‘other:‘, kw 
3 >>> person(‘Bob‘, 35, city=‘Beijing‘)
4 name: Bob age: 35 other: {‘city‘: ‘Beijing‘}
5 >>> person(‘Adam‘, 45, gender=‘M‘, job=‘Engineer‘)
6 name: Adam age: 45 other: {‘gender‘: ‘M‘, ‘job‘: ‘Engineer‘}

 

小结：

• *args是可变参数，args接收的是一个tuple；

• **kw是关键字参数，kw接收的是一个dict。

• 可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过args传入：func((1, 2, 3))；

• 关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过kw传入：func({‘a’: 1, ‘b’: 2})。

四、高级特性

4.1 切片

• 什么是切片：>>> L[0:3] [‘Michael‘, ‘Sarah‘, ‘Tracy‘]
• L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。
• 倒数切片：L[-2:-1]
• 每隔i个取一个数：L[:10:2]
• tuple也是一种list，唯一区别是tuple不可变。因此，tuple也可以用切片操作，只是操作的结果仍是tuple

4.2 迭代

• 可迭代对象：list / tuple / dict / str
• dict 如何进行迭代：

1 >>> d = {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}
2 >>> for key in d:
3 ...     print key
4 默认情况下，dict迭代的是key。
5 如果要迭代value，可以用for value in d.itervalues()。
6 如果要同时迭代key和value，可以用for k, v in d.iteritems()。

 

• 判断一个对象是否可迭代：

1 >>> from collections import Iterable
2 >>> isinstance(‘abc‘, Iterable) # str是否可迭代
3 True
4 >>> isinstance([1,2,3], Iterable) # list是否可迭代
5 True
6 >>> isinstance(123, Iterable) # 整数是否可迭代
7 False

 

• 对list实现类似Java那样的下标循环：

1 >>> for i, value in enumerate([‘A‘, ‘B‘, ‘C‘]):
2 ...     print i, value
3 ...
4 0 A
5 1 B
6 2 C

 

在Python中可以在for循环中同时使用两个变量：

1 >>> for x, y in [(1, 1)print x, y
2 ...
3 1 1
4 2 4
5 3 9

 

4.3 列表生成式

• 强大的生成list的方式，使循环代码用一行搞定，高效简洁：

1 >>> range(1, 11)
2 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
3 >>> [x * x for x in range(1, 11) if x % 2 == 0]
4 >>> [m + n for m in ‘ABC‘ for n in ‘XYZ‘]

 

4.4 生成器

• 列表生成器可以直接生成一个列表，但若我们只用的到这个列表的前几个元素，那便极大地浪费内存空间了。如果可以一边循环一边计算，根据某种算法推算出所需元素，那便要用到我们的生成器（generator）啦！
• 如何创建一个生成器？
  
  1. 第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

1 >>> L = [x * x for x in range(10)]
2 >>> L
3 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
4 >>> g = (x * x for x in range(10))
5 >>> g
6 <generator object <genexpr> at 0x104feab40>

 

• 生成器元素的打印方法？

1 >>> g.next()
2 0
3 >>> g.next()
4 1
5 >>> g = (x * x for x in range(10))
6 >>> for n in g:
7 ...     print n，‘还是使用for循环迭代生成器方便地多呀’

 

• generator非常强大。如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。如著名的斐波那契数列的生成：

1 def fib(max):
2     n, a, b = 0, 0, 1
3     while n < max:
4         print b
5         a, b = b, a + b
6         n = n + 1

 

运行这个fib()们想把它变成一个生成器，每打印一个数字便暂停等待。只需要:

1 print b --> yield b 

 

使用fib生成器的方法便是for循环调用：

1 for i in fib(6): print i 

 

• 总结：普通的函数为顺序执行，遇到return停止；生成器则遇到yield语句才会暂停。

五、函数式编程

5.1 高阶函数

变量也可以指向函数

5.2 返回函数
5.3 匿名函数
5.4 装饰器
5.5 偏函数