Python简要复习

Python程序设计复习

Python基础知识

python的特点

兼具编译型和解释型特性，兼顾过程式、函数式和面向对象编程范式的通用编程语言

解释型语言无需像编译型需要一次性的编译成机器码，然后运行，而是由名叫解释器的程序动态的将源代码逐句转化成机器代码执行

.py->.pyc

在python环境中Python会将.pyc文件存储在__pycache__的目录下，并在文件名中加入Python版本标识字段

当运行源文件时，Python会先在相应位置寻找.pyc文件，找到.pyc后查看是否有改动，若有改动需要重新编译成字节码

Python程序无法一次性编译成机器码，是先变成字节码.pyc，然后由python虚拟机解释执行

pip包管理器

pip help #列出pip的子命令
pip install <packkage>
pip install <package>==<version>
pip uninstall <package>
pip list

python脚本

#!/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函数

Unicode和字符串

字符是文本的最小组成部分

字符集是人为筛选的多个字符的集合

编码规则是将字符集中的字符转化为可存储的字节序列所按照的标准

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表达式

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 "", 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