python学习笔记

边学边整理的python学习心得，希望我们都能熟练的运用这个技能。

Python

输出方式

表达式

print()

输出

不换行输出

end = ' '

标识符

英文、数字及下划线，不能以数字开头

区分大小写

以下划线开头

以单下划线开头：代表不能直接访问的类属性

通过类提供的接口进行访问

不能用from xxx import *导入

以双下划线开头：代表类的私有成员

以双下划线开头和结尾：代表特殊方法专用的标识，如__init__代表类的构造函数

函数

内置函数

print()

输出

type()

查询类型

int()

定义整数

str()

定义字符串

float()

定义浮点数

input()

输入元素

divmod(a,b)

表示a/b，返回商和余数

round(x,d)

对x四舍五入，d是小数截取位数

len()

列表元素个数

max()

返回列表元素最大值

min()

返回列表元素最小值

pow(x,y)

计算x的y次方

range()

生成序列

初始值（可省略），终值，步长值

结合range()和len()函数以遍历一个序列的索引

>>>a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ'] >>> for i in range(len(a)): ... print(i, a[i])

使用range()函数来创建一个列表

>>>list(range(5)) [0, 1, 2, 3, 4]

range(n)

n为序列生成数量

（0,n）

0....n-1

yield()

语句

if 语句

语法： if condition_1: statement_block_1 elif condition_2: statement_block_2 else: statement_block_3

如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句 如果 "condition_1" 为False，将判断 "condition_2" 如果"condition_2" 为 True 将执行 "statement_block_2" 块语句 如果 "condition_2" 为False，将执行"statement_block_3"块语句

if 嵌套

在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中

del 语句

语法：del var1[,var2[,var3[....,varN]]]

删除实体变量： >>> del a

for...in 循环语句

语法： for <variable> in <sequence>: <statements> else: <statements>

>>> vec = [2, 4, 6] >>> [3*x for x in vec] [6, 12, 18]

>>> [[x, x**2] for x in vec] [[2, 4], [4, 16], [6, 36]]

>>> [3*x for x in vec if x > 3] [12, 18] >>> [3*x for x in vec if x < 2] []

>>> vec1 = [2, 4, 6] >>> vec2 = [4, 3, -9] >>> [x*y for x in vec1 for y in vec2] [8, 6, -18, 16, 12, -36, 24, 18, -54] >>> [x+y for x in vec1 for y in vec2] [6, 5, -7, 8, 7, -5, 10, 9, -3] >>> [vec1[i]*vec2[i] for i in range(len(vec1))] [8, 12, -54]

>>> [str(round(355/113, i)) for i in range(1, 6)] ['3.1', '3.14', '3.142', '3.1416', '3.14159']

while 循环语句

语法：while 判断条件(condition)： 执行语句(statements)……

语法： while <expr>: <statement(s)> else: <additional_statement(s)>

def 语句

自定义函数

def 函数名（参数列表）: 函数体

def functionname([formal_args,] *var_args_tuple ): "函数_文档字符串" function_suite return [expression]

加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

def functionname([formal_args,] **var_args_dict ): "函数_文档字符串" function_suite return [expression]

加了两个星号 ** 的参数会以字典的形式导入。

break 语句

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。

continue 语句

continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

pass 语句

空语句，是为了保持程序结构的完整性。 pass 不做任何事情，一般用做占位语句

lambda

创建匿名函数

语法： lambda [arg1 [,arg2,.....argn]]:expression

表达式

return 语句

退出函数

表达式

import 语句

运算符

\n

转义符号

反斜杠可以用来转义，字符串前使用r可以让反斜杠不发生转义。

算术运算符

+

加 - 两个对象相加

-

减 - 得到负数或是一个数减去另一个数

*

乘 - 两个数相乘或是返回一个被重复若干次的字符串

/

除 - x 除以 y

//

取整除 - 向下取接近商的整数

%

取模 - 返回除法的余数

**

幂 - 返回x的y次幂

比较（关系）运算符

==

等于号

！=

不等于

<>

python3中不使用

>

大于 - 返回x是否大于y

<

小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写

>=

大于等于 - 返回x是否大于等于y

<=

小于等于 - 返回x是否小于等于y

赋值运算符 二元增强赋值操作符

=

简单的赋值运算符

c = a + b 将 a + b 的运算结果赋值为 c

+=

加法赋值运算符

c += a 等效于 c = c + a

-=

减法赋值运算符

c -= a 等效于 c = c - a

*=

乘法赋值运算符

c *= a 等效于 c = c * a

/=

除法赋值运算符

c /= a 等效于 c = c / a

%=

取模赋值运算符

c %= a 等效于 c = c % a

**=

幂赋值运算符

c **= a 等效于 c = c ** a

//=

取整除赋值运算符

c //= a 等效于 c = c // a

:=

海象运算符

可在表达式内部为变量赋值 Python3.8 版本新增运算符

在这个示例中，赋值表达式可以避免调用 len() 两次: if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)")

逻辑运算符

and

x and y

布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值

or

x or y

布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值

not

not x

布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True

位运算符

按位运算符是把数字看作二进制来进行计算的

成员运算符

in

如果在指定的序列中找到值返回 True，否则返回 False

not in

如果在指定的序列中没有找到值返回 True，否则返回 False

身份运算符

is

is 是判断两个标识符是不是引用自一个对象

is not

is not 是判断两个标识符是不是引用自不同对象

运算符优先级 按照最高到最低

** 指数 (最高优先级)

~ + - 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)

* / % // 乘，除，求余数和取整除

+ - 加法减法

>> << 右移，左移运算符

& 位 'AND'

^ | 位运算符

<= < > >= 比较运算符

== != 等于运算符

= %= /= //= -= += *= **= 赋值运算符

is is not 身份运算符

in not in 成员运算符

not and or 逻辑运算符

标准的数据类型

Numbers(数字)

数字类型

int(有符号整型)

通常被称为是整型或整数，是正或负整数，不带小数点

4种进制

十进制

二进制 以0b或0B开头

八进制 以0o或0O开头

十六进制 以0x或0X开头

float(浮点型)

浮点型由整数部分与小数部分组成

科学计数法

使用字母e或E作为幂的符号，以10位基数

<a>e<b>

表示a*10的b次方

（2.5e2 = 2.5 x 10² = 250）

取值范围和小数精度都存在限制

取值范围数量级：-10的308次方至10的308次方

精度数量级：10的-16次方

53位二进制表示小数部分

二进制表示小数，可以无限接近，但不完全相同

浮点数间运算存在不确定尾数，不是bug

bool(布尔型)

python2中没有布尔型，用1和0表示True OR False

complex(复数)

复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

long(长整型[也可以代表八进制和十六进制])

python2中使用

String(字符串)

字串列表2种取值顺序

从左到右，索引默认0开始

最大范围是字符串长度少1

从右到左，索引默认-1开始

最大范围是字符串开头

一种特殊的元组

Tuple(元组)

用 ( )标识

不能二次赋值，相当于制度列表

其中的类型可以不相同

重新赋值的元组，绑定到新的对象了，不是修改了原来的对象

二次赋值和重新赋值是不同的概念

元组是一个不可变序列，所谓的元组“不可变”是指元组中的每个元素它的内存指向永远不变。元组本身所指向的内存，实际上保存的是元组内数据的内存地址集合，元组一旦建立，这个内存地址集合就不能修改和删除了。一旦集合内的地址发生改变，就必须重新分配元组空间保存新的内存地址集。

元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用

元素不可以修改，但是可以包含可变对象，如列表；可以对元组进行连接组合；

元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组

函数

tuple(iterable)

将可迭代系列转换为元组

不可变数据

List(列表)

用[ ]标识

有序的对象结合

索引

切片

接受第三个参数，表示步长值

[0:3:2]

如果第三个参数为负数表示逆向读取

列表的数据项不需要具有相同的类型

逗号分隔值

列表可以嵌套

>>> matrix = [ ... [1, 2, 3, 4], ... [5, 6, 7, 8], ... [9, 10, 11, 12], ... ]

以下实例将3X4的矩阵列表转换为4X3列表： >>> [[row[i] for row in matrix] for i in range(4)] [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

>>> transposed = [] >>> for i in range(4): ... transposed.append([row[i] for row in matrix]) ... >>> transposed [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

>>> transposed = [] >>> for i in range(4): ... # the following 3 lines implement the nested listcomp ... transposed_row = [] ... for row in matrix: ... transposed_row.append(row[i]) ... transposed.append(transposed_row) ... >>> transposed [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

函数

list(seq)

将元组转换为列表

方法

list.append(obj)

在列表末尾添加新的对象

list.count(obj)

统计某个元素在列表中出现的次数

list.extend(seq)

在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

list.index(obj)

从列表中找出某个值第一个匹配项的索引位置

list.insert(index, obj)

将对象插入列表

list.pop([index=-1])

移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

list.remove(obj)

移除列表中某个值的第一个匹配项

list.reverse()

反向列表中元素

list.sort( key=None, reverse=False)

对原列表进行排序

list.clear()

清空列表

list.copy()

复制列表

Set(集合)

可以使用大括号 { } 或者 set() 函数创建集合

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。

创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

内置方法

add() 为集合添加元素

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作

clear() 移除集合中的所有元素，清空集合

copy() 拷贝一个集合

difference() 返回多个集合的差集

difference_update() 移除集合中的元素，该元素在指定的集合也存在。

discard() 删除集合中指定的元素

移除集合中的元素，且如果元素不存在，不会发生错误。

intersection() 返回集合的交集

intersection_update() 返回集合的交集。

isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。

issubset()

判断指定集合是否为该方法参数集合的子集

issuperset() 判断该方法的参数集合是否为指定集合的子集

pop() 随机移除元素

remove() 移除指定元素

将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

symmetric_difference() 返回两个集合中不重复的元素集合。

symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

union() 返回两个集合的并集

update() 给集合添加元素

添加元素，且参数可以是列表，元组，字典等

元素可以有多个，用逗号分开

Dictionary(字典)

用{ }创建

无序的对象集合

元素是键值对

元素通过键来存取

由索引(key)和对应的值value组成

一个无序的 键(key) : 值(value) 的集合

键(key)必须使用不可变类型

在同一个字典中，键(key)必须是唯一的。 不允许同一个键出现两次

d = {key1 : value1, key2 : value2 }

方法

del dict # 删除字典

del dict['Name'] # 删除键 'Name'

radiansdict.clear()

删除字典内所有元素，清空

radiansdict.copy()

返回一个字典的浅复制

radiansdict.fromkeys()

创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

radiansdict.get(key, default=None)

返回指定键的值，如果值不在字典中返回default值

key in dict

如果键在字典dict里返回true，否则返回false

radiansdict.items()

以列表返回可遍历的(键, 值) 元组数组

radiansdict.keys()

返回一个迭代器，可以使用 list() 来转换为列表

radiansdict.setdefault(key, default=None)

和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

radiansdict.update(dict2)

把字典dict2的键/值对更新到dict里

radiansdict.values()

返回一个迭代器，可以使用 list() 来转换为列表

pop(key[,default])

删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

popitem()

随机返回并删除字典中的最后一对键和值。

函数

str(dict) 输出字典，以可打印的字符串表示

type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。

可变数据

包

模块

导入

import 语句

import module1[, module2[,... moduleN]

一个模块只会被导入一次，不管执行了多少次import

from … import 语句

from modname import name1[, name2[, ... nameN]]

from … import * 语句

from modname import *

可理解为对应于一个文件

定义了某些函数和变量

函数

类

将数据和操作进行封装，以便将来的复用。

总是位于一个模块中

class语句

class中可以用def init(self，参数1，参数2，参数3）初始化

方法

__init__()

__左右两边是双下划线__

__init__方法的第一参数永远是self

self表示创建的类的实例本身，而非类

self在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。

self在定义时需要定义，但是在调用时会自动传入

self的名字并不是规定死的，但是最好还是按照约定是用self

实例

instance

父类也称为超类（superclass）

子类

继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法

super()是一个特殊的函数，帮助Python将父类和子类关联起来

包是python模块文件所在的目录，且该目录下必须存在__init__.py文件。

package

必须包括__init__.py

包的为首有_init_.py文件，包是一个目录；判断子包的标准，看文件夹里面是否有_init_.py文件

迭代器

方法

iter()

next()

list = [1,2,3,4] it = iter(list) print(next(it)) print(next(it)) print(next(it)) print(next(it))

1 2 3 4

StopIteration异常

用于标识迭代的完成，防止出现无限循环的情况

生成器

数学函数

abs(x) 返回数字的绝对值，如abs(-10) 返回 10

ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5

cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃，使用 (x>y)-(x<y) 替换。

exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045

fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0

floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4

log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0

log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0

max(x1, x2,...) 返回给定参数的最大值，参数可以为序列。

min(x1, x2,...) 返回给定参数的最小值，参数可以为序列。

modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。

pow(x, y) x**y 运算后的值。

round(x [,n]) 返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。

sqrt(x) 返回数字x的平方根。

随机数函数

choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。

randrange ([start,] stop [,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1

random() 随机生成下一个实数，它在[0,1)范围内。

seed([x]) 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。

shuffle(lst) 将序列的所有元素随机排序

uniform(x, y) 随机生成下一个实数，它在[x,y]范围内。

三角函数

acos(x) 返回x的反余弦弧度值。

asin(x) 返回x的反正弦弧度值。

atan(x) 返回x的反正切弧度值。

atan2(y, x) 返回给定的 X 及 Y 坐标值的反正切值。

cos(x) 返回x的弧度的余弦值。

hypot(x, y) 返回欧几里德范数 sqrt(x*x + y*y)。

sin(x) 返回的x弧度的正弦值。

tan(x) 返回x弧度的正切值。

degrees(x) 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0

radians(x) 将角度转换为弧度

数学常量

pi 数学常量 pi（圆周率，一般以π来表示）

e 数学常量 e，e即自然常数（自然常数）

is 与 == 区别： is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

string、list 和 tuple 都属于 sequence（序列）

模块 + 全局变量 + 函数 类似于 类 + 属性 + 方法的单例模式类

类是一个文件的一段代码；模块（module）是一个文件；包是多个文件，也可以说是多个模块，调用包需要加__init__.py文件，此文件可以是空，也可以有代码