Python基础笔记

(1) r’ ’ 表示’ ‘中的内容不转义，转义符号用 \
(2) 理解变量在内存中的表示：
a = ‘ABC’
Python解释器做了两步工作：1）在内存中创建一个字符串’ABC’ 2）在内存中创建一个名字为a的变量，并把它指向’ABC’
b = a
意思是赋值，把变量a赋值给变量b，即变量b指向变量a指向的数
(3) Python允许用”’ ””来表示多行数据

>>> print ('''1111
... 222
... 333
... 444''')
1111
222
333
444
>>>

(4) //与/的区别

>>> 10/3
3
>>> 10.0/3
3.3333333333333335
>>> 10//3
3
>>> 10.0//3
3.0

// 只取结果的整数部分，所以即使除不尽也是整数
(5) 格式化练习题：
小明的成绩从去年的72分提升到了今年的85分，请计算小明成绩提升的百分点，并用字符串格式化显示出’xx.x%’，只保留小数点后1位：

 s1 = 72
 s2 = 85
 r = 100*(float(s2-s1)/s1)
 print('%.1f %%' % r)

#使用format()来格式化，传入的参数依次替换{0}{1}...
print ('{0}成绩提升了{1:.1f}%'.format('小明',r))

小明成绩提升了18.1%
>>> 

(6) 列表list
下标索引比元素少1，添加元素append()，插入元素insert()，删除元素pop()

 classmates = ['Maria','Jane','Michcel']
 classmates.insert(2,'Peter')
 classmates.pop(1)
'Jane'

(7) 元组tuple
1) 元组与列表很类似，唯一的区别在于一旦初始化就不能被修改。因此代码比较安全！但可以通过list进行修改！！

 t = ('a','11',['A','B'])
 t[2][0]='x'
 t[2][1]='y'
 >>> t
('a', '11', ['x', 'y'])

2) 为了与数学运算小括号区别，如果是1个元素时就加个逗号

>>> t = (1)
>>> t
1
>>> t = (1,)
>>> t
(1,)
>>>

(8) 字典dict
在其他语言中也称为map，使用键-值(key-value)对存储，具有极快的查找速度。
key如果不存在就会报错，因此需要判断key是否存在。有两种方式：

 d = {'Maria':80,'Michcel':60,'Peter':90}
>>> d
{'Michcel': 60, 'Peter': 90, 'Maria': 80}
>>> d.get('Thomas',-1)
-1
>>> 'Thomas' in d
False
>>>

用pop(key)删除元素：

>>> d.pop('Peter')
90
>>> d
{'Michcel': 60, 'Maria': 80}
>>>

与list比较
1）查找和插入速度极快
2）需要占用大量的内存
是用空间换取时间的方法

dict的key必须是不可变对象，因为dict根据key来计算对应的value的存储位置。使用的算法是hash算法。

（9） Set
set与dict类似，也是一组key的集合，唯一的区别在于不存储value。因此key不能重复。
要创建一个set，需要提供一个list作为输入集合：

>>> s = set([1,2,3])
>>> s
set([1, 2, 3])
>>> ss = set(1,2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: set expected at most 1 arguments, got 2
>>> ss = set(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

重复元素会被自动过滤，添加元素add()，删除元素remove():

s = set([1,1,2,2,2,3])
>>> s
set([1, 2, 3])
>>> s.add(4)
>>> s
set([1, 2, 3, 4])
>>> s.remove(2)
>>> s
set([1, 3, 4])

set可看成数学意义上的无序和无重复元素的集合，可进行交、并操作。

 s1 = set([2,3,4])
>>> s&s1
set([3, 4])
>>> s |s1
set([1, 2, 3, 4])

 分别将（1，2，3）和（1，2，[3]）放入dict和set中：

 dq = {(1,2,3):1}
>>> dq
{(1, 2, 3): 1}
>>> dq = {(1,2,[3]):1}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

dq = {(1,2,3)}
>>> dq
set([(1, 2, 3)])

s2 = {1,2,3}
>>> s2
set([1, 2, 3])
>>>

s = set((1,2,3))
>>> s
set([1, 2, 3])
>>> s = set((1,2,[3]))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

说明元组tuple也是可迭代对象！！

(10) 可变元素与不可变元素

a = 'abc'
>>> b = a.replace('a','A')
>>> b
'Abc'
>>> a
'abc'
>>>

为什么a没有变？？
始终牢记：a是一个变量，’abc’才是一个对象！
当调用replace时，其作用是在字符串对象’abc‘上。它创建了一个新的字符串’Abc’并返回，b指向其返回值。

(11) 函数
1）def power(x,n=2) 默认参数要放在必选参数之后？？？
2）函数的默认参数必须是不变对象（不能是list）

>>> def add_end(L=[]):
...     L.append('END')
...     return L
...
>>> add_end()
['END']
>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']
>>>

原因：Python函数在定义时，默认参数L的值就被计算出来了，即[]，因为默认参数L是一个变量指向对象[]，每次调用该函数，如果[]中的内容已改变，则下次调用时就会跟着改变。
更改如下：

>>> def add_end(L=None):
...     if L is None:
...             L = []
...     L.append('END')
...     return L
...
>>> add_end()
['END']
>>> add_end()
['END']
>>>

3）定义可变参数，直接在参数前加个*即可！在函数内部，参数numbers接收到的是一个tuple

>>> def calc(*numbers):
...     sum = 0
...     for n in numbers:
...             sum = sum + n*n
...     return sum
...
>>> calc(1,2)
5

# 如果已经有一个list或tuple，要调用一个可变参数该怎么办？？
>>> num = [1,2,3]
>>> calc(*num)
14
>>> calc(num)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in calc
TypeError: can't multiply sequence by non-int of type 'list'
>>>

4）关键字参数
    可变参数在函数内部被组装成tuple;关键字参数则组装成dict

>>> def person(name,age,**kw):
...     print('name:',name,age,'other:',kw)
...
>>> person('Jane',20)
('name:', 'Jane', 20, 'other:', {})
>>> person('Jane',20,city='Beijing')
('name:', 'Jane', 20, 'other:', {'city': 'Beijing'})
>>>

关键字参数用来拓展函数的功能。例如对于有些是必选项有些事可选项的情况。

# dict作为参数
>>> extra={'city':'Beijing','job':'Engineer'}
>>> person('Jane',30,**extra)
('name:', 'Jane', 30, 'other:', {'city': 'Beijing', 'job': 'Engineer'})
>>>
# **extra表示把这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict

5)命名关键字参数（Python3）略
6）参数组合：*args可变参数，接收的是一个tuple;**kw是关键字参数，接收的是一个dict.

>>> def func(a,b,c=0,*numbers,**kw):
...     print'a=',a,'b=',b,'c=',c,'numbers=',numbers,'kw=',kw
...
>>> func(1,2)
a= 1 b= 2 c= 0 numbers= () kw= {}
>>> func(1,2,3)
a= 1 b= 2 c= 3 numbers= () kw= {}
>>> func(1,2,3,'a','b')
a= 1 b= 2 c= 3 numbers= ('a', 'b') kw= {}
>>> func(1,2,3,'a','b',city='Beijing')
a= 1 b= 2 c= 3 numbers= ('a', 'b') kw= {'city': 'Beijing'}
>>>

 kw={'job':'Engineer'}
 numbers = [5,6,7,8]
>>> func(*numbers,**kw)
a= 5 b= 6 c= 7 numbers= (8,) kw= {'job': 'Engineer'}

7)递归函数
尾递归：在函数返回时调用函数本身，但return语句不能包含表达式。

def fact(n):
    return fact_iter(n, 1)

def fact_iter(num, product):
    if num == 1:
        return product
    return fact_iter(num - 1, num * product)

(12) 切片

>>> L = ['Michael','Maria','Jane','Peter','Bob']
>>> L[0:3]
['Michael', 'Maria', 'Jane']
>>> L[::2]
['Michael', 'Jane', 'Bob']

（13）迭代
Python中的可迭代对象：list、tuple、dict、字符串
判断是否是可迭代对象：

>>> from collections import Iterable
>>> isinstance('abc',Iterable)
True

Python内置的enumerate()函数可以把一个list变成（索引，元素）对，这样就可以在for循环中同时迭代索引和元素本身。

>>> for i,value in enumerate(['a','b','c']):
...     print i,value
...
0 a
1 b
2 c

（14）列表生成式

>>> [x*x for x in range(1,11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> [x*x for x in range(1,11) if x %2 == 0]
[4, 16, 36, 64, 100]
>>> [m + n for m in 'ABC' for n in 'abc']
['Aa', 'Ab', 'Ac', 'Ba', 'Bb', 'Bc', 'Ca', 'Cb', 'Cc']
>>> L=['Hello','World','I','Love']
>>> [s.lower() for s in L]
['hello', 'world', 'i', 'love']
>>> import os
>>> [d for d in os.listdir('.')]
['.idlerc', '.PyCharm2017.1', '3D Objects',

（15）生成器（Generator）
何谓生成器：
答：一边循环一边计算的机制
为什么要创建生成器：
答：因为列表中元素太多，而我们却只访问少量元素，那就太浪费空间。我们通过一边循环一边计算出后续的元素，就不需要创建完整的列表；
如何创建生成器：

>>> g = (x*x for x in range(1,11))
>>> g
<generator object <genexpr> at 0x0523EAD0>
>>> g.next()
1
>>> g.next()
4
>>> g.next()
9
>>> for n in g:
...     print n
...
16
25
36
49
64
81
100

(16) 迭代器
1）迭代对象：例如list、tuple、dict、字符串等
2）迭代器：可以被next()函数调用并不断返回下一个值得对象是迭代器（Iterator）
备注：生成器都是迭代器（因为它课被next()函数调用，）
凡是可作用于for（）都是可迭代对象；
凡是可作用与next()都是迭代器。

>>> from collections import Iterator
>>> from collections import Iterable
>>> isinstance([],Iterable)
True
>>> isinstance([],Iterator)
False
>>> isinstance({},Iterable)
True
>>> isinstance({},Iterator)
False
>>> isinstance('abc',Iterable)
True
>>> isinstance('abc',Iterator)
False
>>> isinstance((x for x in range(10)),Iterable)
True
>>> isinstance((x for x in range(10)),Iterator)
True

可以使用iter()函数将list、dict、str等可迭代对象变成迭代器：

>>> isinstance(iter([]),Iterator)
True
>>> isinstance(iter('abc'),Iterator)
True

问题：为什么list、dict、str等不是迭代器呢？
回答：因为Python得迭代器对象表示的是一个数据流，可以把这个数据流对象看作是一个有序序列，但不知道其长度，只能通过next()函数来计算下一个数据。因此迭代器对象是有惰性的。它可以表示无限大的数据流，而如list却不可以。