python3.5语法学习笔记

一、基本数据类型

1.字符串

字符串换行的3种方式：

strip()去除字符串首尾的指定字符：

split()分割字符串，返回list：

str=‘123’+3

2.list

(1)append&extend

def changeextend(str):
    "print string with extend"
    mylist.extend([40,50,60])
    print ("print string mylist:",mylist)
    return
def changeappend(str):
    "print string with append"
    mylist.append( [7,8,9] )
    print("print string mylist:",mylist )
    return
mylist = [10,20,30]
changeextend( mylist )
print ("print extend mylist:", mylist )
changeappend( mylist )
print ("print append mylist:", mylist )

输出结果：

通过比较可知：

1. 列表可包含任何数据类型的元素，单个列表中的元素无须全为同一类型。
2. append() 方法向列表的尾部添加一个新的元素；extend()方法只接受一个列表作为参数，并将该参数的每个元素都添加到原有的列表中。
3. 列表是以类的形式实现的。“创建”列表实际上是将一个类实例化。因此，列表有多种方法可以操作。

注：
当 list 类型的对象进行 append 操作时，实际上追加的是该对象的引用。

id() 函数：返回对象的唯一标识，可以类比成该对象在内存中的地址。

import copy

alist=[]
num = [2]
alist.append(num)
print(id(num)==id(alist[0]))

alist=[]
alist.append(copy.deepcopy(num))
print(id(num)==id(alist[0]))

a=2
b=2
print(a==b)

输出结果：

如上例所示，当 num 发生变化时(前提是 id(num) 不发生变化），alist 的内容随之会发生变化。往往会带来意想不到的后果，想避免这种情况，可以采用深拷贝解决。

3.元组

4.generator(生成器)

参考资料：https://www.cnblogs.com/zywscq/p/5774567.html
python中的generator保存的是算法，真正需要计算出值的时候才会去往下计算出值。它是一种惰性计算（lazy evaluation）。
（1）g = (x * x for x in range(10)) # 不是生成一个tuple，而是生成一个generator
（2）

def fib():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b


f = fib()
print f, next(f), next(f), next(f)
#  <generator object fib at 0x7f89769d1fa0> 0 1 1

在函数中使用yield关键字，函数就变成了一个generator。函数里有了yield后，执行到yield就会停住，当需要再往下算时才会再往下算。
如上例，第一次输出f，它就是一个generator，之后每次next，它就执行到yield a。当然其实平常很少用到next()，我们直接用for循环就可以遍历一个generator，其实for循环的内部实现就是不停调用next()。

生成器可以避免不必要的计算，带来性能上的提升；而且会节约空间，可以实现无限循环（无穷大的）的数据结构。
注：

import jieba
str='小明硕士毕业于中国科学院计算所，后在日本京都大学深造'
seg=jieba.cut(str)
print(seg)
print(list(seg))
print(' '.join(seg))

seg1=jieba.lcut(str)
print(seg1)
print(' '.join(seg1))

可以看出：第一个seg是generator,所以print(list(seg))后面的print(’ ‘.join(seg))执行结果为’'

4.可迭代对象(Iterable)和迭代器(Iterator)的概念

可以直接作用于for循环的对象统称为可迭代对象：Iterable。包括集合数据类型（list、tuple、dict、set、str等）和生成器（generator）。
可以用isinstance()来判断一个对象是否为iterable对象

迭代器（Iterator）表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。
**生成器（generator）都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。**把list、dict、str等Iterable变成Iterator可以使用iter()函数。

Python的for循环本质上就是通过不断调用next()函数实现的，例如：

for x in [1, 2, 3, 4, 5]:
    pass

实际上完全等价于：

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

二、Python 直接赋值、浅拷贝和深度拷贝解析

参考资料：
http://www.runoob.com/w3cnote/python-understanding-dict-copy-shallow-or-deep.html
1.直接赋值：其实就是对象的引用（别名）。

2.浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。

3.深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。

import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象
 
b = a                       #赋值，传对象的引用
c = copy.copy(a)            #对象拷贝，浅拷贝
d = copy.deepcopy(a)        #对象拷贝，深拷贝
 
a.append(5)                 #修改对象a
a[4].append('c')            #修改对象a中的['a', 'b']数组对象
 
print( 'a = ', a )
print( 'b = ', b )
print( 'c = ', c )
print( 'd = ', d )

输出结果：

三、import机制

https://www.cnblogs.com/yan-lei/p/7828871.html
模块（module）：文件是物理上组织方式"module_name.py"，模块是逻辑上组织方式"module_name"。
包（package）：一个有层次的文件目录结构（必须带有一个__init__.py文件）。

四、变量作用域

全局变量 和 局部变量
1：作用范围不一样 全局 在模块里面都能调用 函数的局部变量只能用于函数内
2: 当全局和局部变量同名且同时存在的时候 函数优先调用局部变量
3：当局部变量没有 就优先用全局的
4: global声明这是一个全局变量

五 正则表达式

六

t=['a','b']
for s in t:
	s += '1'
#结果：t=['a','b']

 t=[['a'],['b']]
 for l in t:
 	l.append('1')
#结果： t=[['a','1'],['b','1']]

在python语言中，链表是结构化对象，l是对t中链表对象的引用，因此改变l的值，对应的，t的值就会改变。