兼具编译型和解释型特性，兼顾过程式、函数式和面向对象编程范式的通用编程语言
解释型语言无需像编译型需要一次性的编译成机器码，然后运行，而是由名叫解释器的程序动态的将源代码逐句转化成机器代码执行
.py->.pyc
在python环境中Python会将.pyc文件存储在__pycache__的目录下，并在文件名中加入Python版本标识字段
当运行源文件时，Python会先在相应位置寻找.pyc文件，找到.pyc后查看是否有改动，若有改动需要重新编译成字节码
Python程序无法一次性编译成机器码，是先变成字节码.pyc，然后由python虚拟机解释执行
pip help #列出pip的子命令
pip install <packkage>
pip install <package>==<version>
pip uninstall <package>
pip list
#!/usr/bin/env python
注意条件判断语句
if __name__=='__main__'
__name__ 是python的内置属性，是系统全局变量！每一个py文件都有一个属于自己的__name__
如果py文件作为模块被导入(import)，那么
__name__就是该py文件的文件名(也称 模块名)；如果py文件直接运行时(Ctrl+Shift+F10)，那么
__name__默认等于字符串__main__;
列表是若干对象的集合，其中的类型可以是不同的
In [1]: x=[1,3.14,"hello"]
In [2]: x
Out[2]: [1, 3.14, 'hello']
列表也是可变对象,指在对象创建后它的值仍能被修改
列表切片
使用冒号分割两个下标，分别代表起始下标(包含)和终止下标(不包含)
In [13]: x=[1,3.14,"hello"]
In [14]: a=x[0:-1]
In [15]: a
Out[15]: [1, 3.14]
列表常用方法
list.append(x)
list.extend(x) #将序列x中的所有元素依次添加至列表List的尾部
list.insert(index,x)#在列表指定位置插入对象x
list.pop([index])#删除尾部或者指定位置的元素
list.remove(x)#在列表中删除首次出现的指定元素x
list.clear#删除列表中的所有元素
list.index(x)#返回x元素的下标
list.count(x)#返回指定元素x的出现次数
list.sort()#对列表元素进行正序排列
list.reverse()
list.copy()#进行浅拷贝
In [22]: x
Out[22]: [1, 3.14, 'hello']
In [23]: x.append('world')
In [25]: x
Out[25]: [1, 3.14, 'hello', 'world']
In [26]: a=[1,2,3]
In [27]: x.extend(a)
In [28]: x
Out[28]: [1, 3.14, 'hello', 'world', 1, 2, 3]
列表推导式
In [29]: a=[i for i in [1,'2','3']]
In [30]: a
Out[30]: [1, '2', '3']
In [31]: [(i,j)for i in range(10) if i!=5 for j in range(3) if j>=2]
Out[31]: [(0, 2), (1, 2), (2, 2), (3, 2), (4, 2), (6, 2), (7, 2), (8, 2), (9, 2)]
tuple是任意对象组成的序列，不支持原地修改，即元组已经创建，其中的元素用任何方式无法改变(不可变特性)
In [33]: x=(1,2,3)
In [34]: x
Out[34]: (1, 2, 3)
In [35]: y=tuple()
In [36]: y
Out[36]: ()
注意：元组无
sort和reverse方法但是有
sorted和reversed方法，会返回一个新的序列对象
In [56]: x=(1,2,3,(1,2),[1,2,3])
In [57]: x
Out[57]: (1, 2, 3, (1, 2), [1, 2, 3])
In [58]: x[4][0]=None
In [59]: x
Out[59]: (1, 2, 3, (1, 2), [None, 2, 3])
In [61]: x[4]=None
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-61-dd313a01e66b> in <module>
----> 1 x[4]=None
TypeError: 'tuple' object does not support item assignment
字典是键值对的可变集合
可用不可变对象作为键
In [75]: x=dict(zip(keys,values))
In [76]: x
Out[76]: {'name': 'lihua', 'age': 12}
In [83]: x.get('name')#获取对应的键的值
Out[83]: 'lihua'
In [84]: x.update({'gender':'male'})
In [85]: x
Out[85]: {'name': 'lihua', 'age': 12, 'gender': 'male'}
keys() values items()分别对应字典的键、值和对象
键值对不可重复
实际是它的键不可重复
set集合是无序可变序列，使用一对大括号{}界定，不允许重复
>>> a={1,2,3}
>>> type(a)
<class 'set'>
In [110]: a
Out[110]: {1, 2, 3, 4}
In [111]: a.remove(5)
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-111-fa8c667230ef> in <module>
----> 1 a.remove(5)
KeyError: 5
In [112]: a.discard(5)
In [113]: a
Out[113]: {1, 2, 3, 4}
集合的并交和差集运算
In [113]: a
Out[113]: {1, 2, 3, 4}
In [117]: s={1,3,5}
In [118]: a.union(s)
Out[118]: {1, 2, 3, 4, 5}
In [119]: a.intersection(s)
Out[119]: {1, 3}
In [120]: a.difference(s)
Out[120]: {2, 4}
浅拷贝出现在copy函数、列表切片
如果要将嵌套的每一次都拷贝，那就需要deep copy函数
字符是文本的最小组成部分
字符集是人为筛选的多个字符的集合
编码规则是将字符集中的字符转化为可存储的字节序列所按照的标准
UTF-8可变长编码方案
若码位小于127(0x7f) 单个字节表示
码位在128-2047 两个字节
大于2048 三或者四个
汉语通常编译成三个字节
传递实时参数的参数解包
可以用列表 元组 字典 集合等可迭代对象作为实参，并在实参名称前面加个’*’
In [174]: def func(a,b,c):
...: print(a,b,c)
...:
In [175]: func(*[1,2,3])
1 2 3
如果是字典对象需要在前面加上’**’
'*‘和’**'如果出现在函数定义当中代表接受任意数量的参数，出现在函数调用代表参数解包
lambda arg1,arg2,...,argN:expression
执行lambda表达式会生成一个函数对象，可以将其赋给变量，供之后调用，这与使用def语句定义函数无区别
In [178]: f=lambda x, y: x + y
In [179]: f(1,2)
Out[179]: 3
global关键字
迭代器
>>> m=map(lambda x:x**2,[1,2,3])
>>> it1=m.__iter__()
>>> it1 is m
True
>>> it1.__next__()
1
>>> it1.__next__()
4
>>> it1.__next__()
9
>>> it1.__next__()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
#斐波那契函数迭代器
class Fibs:
def __init__(self,n=10):
self.a=0
self.b=1
self.n=n
def __iter__(self):
return self
def __next__(self):
self.a,self.b=self.b,self.a+self.b
if self.a>self.n:
raise StopIteration
return self.a
TODO
