转义字符

描述

\(在行尾时)

续行符

\\

反斜杠符号

\'

单引号

\"

双引号

\a

响铃

\b

退格(Backspace)

\e

转义

\000

空

\n

换行

\v

纵向制表符

\t

横向制表符

\r

回车

\f

换页

\oyy

八进制数，yy代表的字符，例如：\o12代表换行

\xyy

十六进制数，yy代表的字符，例如：\x0a代表换行

\other

其它的字符以普通格式输出

& -> 与

| -> 或

^ -> 异或

- -> 取反

<< -> 左移动

 >> -> 右移动

list01 = [1,2,3]

list01.append(4)

print("list01:", list01)

list02 = list01

list03 = list01.copy()

print("list02:", list02)

list02[1] = 0

print("list03:", list03)

print("list02:", list02)

print("list01:", list01)

list01.clear()

list01[2:2] = [8]

print("list03:", list03)

print("list02:", list02)

print("list01:", list01)

list01: [1, 2, 3, 4]

list02: [1, 2, 3, 4]

list03: [1, 2, 3, 4]

list02: [1, 0, 3, 4]

list01: [1, 0, 3, 4]

[]

list03: [1, 2, 3, 4]

list02: [1, 0, 8, 3, 4]

list01: [1, 0, 8, 3, 4]

append:用于将一个对象附加到列表末尾

=:这种复制（同一对象）

copy：复制列表（两个不同对象）

clear：清空该列表

在列表中插入一个元素

len()

返回列表的长度

max()

返回列表中最大值

min()

返回列表中最小值

list()

用于将元组转化为列表

append(object)

用于将一个对象附加到列表末尾

>>> list01 = [1, 2, 3]

>>> list.append(4)

>>> list01.append(4)

>>> list01

[1, 2, 3, 4]

clear()

清空列表的内容

>>> list01 = [1, 2, 3]

>>> list01.clear()

>>> list01

[]

copy()

复制列表（复制成两个不同对象）

>>> list01 = [1, 2, 3, 4]

>>> list02 = list01.copy()

>>> list02

[1, 2, 3, 4]

count(value)

计算指定的元素在列表中出现了多少次

>>> list01 = [1, 2, 3, 4, 1, 2, [3, 4], [1, 2, [3, 4]]]

>>> list01.count(3)

1

>>> list01.count([3, 4])

1

extend(list)

能够同时将多个值附加到列表末尾，为此可将这些值组成的序列作为参数提供给方法extend

>>> list01 = [1, 2, 3, 4]

>>> list02 = [5, 6, 7, 8]

>>> list01 + list02

[1, 2, 3, 4, 5, 6, 7, 8]

>>> list01

[1, 2, 3, 4]

>>> list01.extend(list02)

>>> list01

[1, 2, 3, 4, 5, 6, 7, 8]

index(value)

在列表中查找指定值第一次出现的索引

>>> list01 = ["1", "2", "3", "4"]

>>> list01.index('3')

2

insert(index,object)

用于将一个对象插入列表

>>> list01 = [1, 2, 4, 5]

>>> list01.insert(2,"three")

>>> list01

[1, 2, 'three', 4, 5]

pop([index])

从列表中删除一个元素（末尾为最后一个元素），并返回该元素

（pop是唯一既修改列表有返回一个非None值的列表方法；使用pop可实现一种常见的数据结构——栈（stack），后进先出（LIFO））

>>> list01 = [1, 2, 3, 4]

>>> list01.pop()

4

>>> list01

[1, 2, 3]

>>> list01.pop(0)

1

>>> list01

[2, 3]

remove(value)

用于删除第一个为指定值的元素

>>> list01 = [1, 2, 3, 4, 2, 4, 3, 1]

>>> list01.remove(1)

>>> list01

[2, 3, 4, 2, 4, 3, 1]

reverse()

按相反的顺序排列列表中的元素（把列表元素反过来）

>>> list01 = [1, 2, 3, 4]

>>> list01.reverse()

>>> list01

[4, 3, 2, 1]

sort()

对列表进行升序排序

sorted()

对列表进行升序排序，或对字符串也可以进行排序操作

len()

返回元组长度

max()

返回元组最大值

min()

返回元组最小值

tuple()

用于将列表转换为元组

sum()

求元组中所有元素之和

len(dict)

计算字典元素个数

str(dict)

输出字典以可打印的字符串表示

type(variable)

返回输入的变量类型

clear()

用于清除字典中的所有元素

copy()

用于复制字典

get(key,[,d])

该方法中key是字典的键值，d是键值的默认值。若存在key就返回其值，否则返回d

>>> dict.get("D","闪现")

'闪现'

>>> dict

{'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'}

items()

该方法使用字典中元素创建一个以(key,value)为一组的元组对象

>>> dict.items()

dict_items([('Q', '新月打击'), ('W', '苍白之瀑'), ('E', '月之降临'), ('R', '月神冲刺')])

keys()

该方法使用字典中的键值来创建一个列表对象

>>> dict.keys()

dict_keys(['Q', 'W', 'E', 'R'])

values

该方法使用字典中键值来创建一个列表对象

>>> dict.values()

dict_values(['新月打击', '苍白之瀑', '月之降临', '月神冲刺'])

popitem()

该方法用于删除字典中的随机一个元素

>>> dict.popitem()

('R', '月神冲刺')

>>> dict

{'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临'}

setdefault(key[,d])

该方法中key是字典的键值，d是键值的默认值。若key存在，就返回其值，否则返回d

>>> dict.setdefault("D","闪现")

'闪现'

>>> dict

{'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺', 'D': '闪现'}

update(E)

该方法中E是字典对象，由字典对象E来更新此字典

>>> print(dict.update({"D":"闪现"}))

{'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺', 'D': '闪现'}

fromkeys()

创建一个新字典，其中包括指定的键，且没个键对应的值都是None

>>> {}.fromkeys(['Q','W','E','R'])

{'Q': None, 'W': None, 'E': None, 'R': None}

values()

返回一个由字典中的值组成的字典视图

>>> d = {}

>>> d[1] = 1

>>> d[2] = 2

>>> d[3] = 3

>>> d.values()

dict_values([1, 2, 3])

先定义一个空字典

向字典中添加元素

输出字典视图

打印字典视图

运算符说明

Python运算符

优先级

索引运算符

x[index]或x[index:index2[:index3]]

18、19

属性访问

x.attrbute 

17

乘方

**

16

按位取反

~

15

符号运算符

+或-

14

乘、除

*、/、//、%

13

加、减

+、-

12

位移

>>、<<

11

按位与

&

10

按位异或

^

9

按位或

|

8

比较运算符

==、!=、>、>=、<、<= 

7

is运算符

is、is not

6

in运算符

in、not in

5

逻辑非

not

4

逻辑与

and

3

逻辑或

or

2

%%

百分号标记

%c

字符及其ASCII码

%s

字符串

%d

有符号整数（十进制）

%u

无符号整数（十进制）

%o

无符号整数（八进制）

%x

无符号整数（十六进制）

%X

无符号整数（十六进制大写字符）

%e

浮点数字（科学计数法 ）

%E

浮点数字（科学计数法，用E代替e）

%f

浮点数字（用小数点符号）

%g

浮点数字（根据值的大小采用%e或%f）

%G

浮点数字（类似于%g）

%p

指针（用于十六进制打印值的内存地址）

%n

存储输出字符的数量放进参数列表下一个变量中

符号

说明

m.n

m是显示的最小总宽度，n是小数点后的位数

-

用于左对齐

+

在正数前面显示加号（+）

#

在八进制数面前显示‘0o’，在十六进制数前面显示'0x‘或者’0X'

0

显示的数字前面填充‘0’取代空格

字符串方法

使用说明

案例

capitalize()

用于将字符串的第一个字母变成大写，其他字母变成小写

>>> str = "i Love you"

>>> str.capitalize()

'I love you'

count(String,start,end)

用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置

>>> s = 'o'

>>> str.count(s)

2

>>> str.count(s,0,5)

0

>>> str.count(s,0,12)

1

find(String,start,end)

用于检测字符串中是否含子字符串。若含有子字符串，则返回开始的索引值；，否则返回 -1

还可以指定位置去查找子串

>>> str = "Python程序设计案例教程"

>>> s = "程序"

>>> str.find(s, 0, len(str))

6

index(String,start,end)

用于检测字符串中是否含子字符串。若含有，则返回开始索引值；否则会报一个异常

>>> str = "Python程序设计案例教程"

>>> s = "程序"

>>> str.index(s, 0, len(str))

6

>>> str.index(s, 7, len(str))

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

ValueError: substring not found

isalnum()

用于检测字符串是否由汉字、字母和数字组成

>>> str = "Python程序设计案例教程"

>>> str.isalnum()

True

>>> str = "Python 程序设计案例教程"

>>> str.isalnum()

False   # 该字符串有空格

join(sequence)

将序列中的元素用指定的字符连接生成一个新的字符串

>>> str = ("Python","程序","设计","案例","教程")

>>> s = "*"

>>> s.join(str)

'Python*程序*设计*案例*教程'

split()

作用与join方法 相反

>>> str = "I love you !"

>>> str.split(" ")

['I', 'love', 'you', '!']

isalpha()

用于检测字符串是否 只有字母和汉字组成

>>> str = "Python程序设计案例教程"

>>> str.isalpha()

True

>>> str = "Python 程序设计案例教程"

>>> str.isalpha()

False    # 该字符串有空格

isdigit()

用于检测字符串是否只由数字组成

>>> str = "Python程序设计案例教程"

>>> str.isdigit()

False

>>> str = "1314520"

>>> str.isdigit()

True

lower()

将字符全部转化为小写

>>> str = "i Love you"

>>> str.lower()

'i love you'

swapcase()

讲字符串大小写互换

>>> str = "I Love You !"

>>> str.swapcase()

'i lOVE yOU !'

upper()

将字符全部转化为大写

>>> str = "i Love you !"

>>> str.upper()

'I LOVE YOU !'

min()

字符串最小值

>>> str = "I love you !"

>>> min(str)

' '

max()

字符串最大值

>>> str = "I love you !"

>>> max(str)

'y'

len()

计数字符串个数

>>> str = "I love you !"

>>> len(str)

12

title()

“标题化”该字符串

>>> str = "I love you !"

>>> str.title()

'I Love You !'

replace(old,new[,max])

用于把字符串中的旧字符串替换成新的字符串

max: 表示替换不超过max次

>>> str = "I do not love you !"

>>> str.replace(" do not "," ")

'I love you !'

translate()

用法和replace方法相同，但不同的的是它只能替换一个字符

>>> str = "I love you !"

>>> str.translate(str.maketrans('LY','ly'))

'I love you !'

center()

通过在两边添加填充字符（默认为空格）让字符串居中

>>> str = "I love you !"

>>> s = "*"

>>> str.center(20,s)

'****I love you !****'

strip()

去除字符串开头和末尾的空格

>>> str = "    I love you !    "

>>> str.strip()

'I love you !'

导包

说明

from math import *

sqrt(9)

第一种导包

后面用起来更简洁

from math import sqrt,pow,floor

第二种导包（可同时导入多个包）

import math

math.sqrt(9)

第三种导包

import math as shuxue

shuxue.sqrt(9)

导包同时可以用(as)重命名

from math as shuxue import *

没有这种，会报错

from math import pow as pf

pf(2,3)

pow(2,3)

导入特定的函数并给它指定别名

赋值

说明

序列解包

>>> x,y,z = 1,2,3

>>> print(x,y,z)

1 2 3

一起赋多个值

>>> x,y,z = 1,2,3

>>> x,y = y,x

>>> print(x,y,z)

2 1 3

两个变量值简易交换

>>> a,b,*rest = [1, 2, 3, 4]

>>> rest

>>> a

>>> b

>>> c,d = rest

>>> c

>>> d

[3, 4]

1

2

3

4

星号运算符（*）来收集多余的值，这样无需确保值和变量的个数相同

链式赋值

>>> a = b = [1, 2]

>>> a == b

True

>>> a is b

True

同等效果
(同一对象)

>>> a = [1, 2]

>>> a = b

>>> a == b

True

>>> a is b

True

>>> a = [1, 2]

>>> b = [1, 2]

>>> a == b

True

>>> a is b

False

这样不是同一对象

语句

说明

pass

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

continue

跳出本次循环，执行下一次循环

break

终止循环

函数

说明

案例

range

tart：计数从start开始。默认是从0开始。例如：range(5)等价于range(0,5)

stop：计数到stop结束，但不包括stop。例如：range(0, 5)是[0, 1, 2, 3, 4]没有5

step：步长，默认为1。例如：range(0,5)等价于range(0,5,1)

print("乘法口诀表：")

for x in range(1, 10):

    for y in range(1, x+1):

        print(y, "*", x, "=", x*y, end="\t\t")

    print()

len

方法返回对象（字符、列表、元组等）长度或项目个数。

complex(real[,imag])

创建一个复数，其值为real + imag * j

dir([object])

返回object对象的属性名称列表。若没有指定参数object，则会返回现有的区域符号表（Loaal Symbol Table）

divmod(a,b)

将a除以b的商与余数以元组类型返回，若a、b是整数或是长整数，返回值为(a/b,a%b),

>>> divmod(5,3)

(1, 2)

exal(expression[,globals[,locals]])

运行expression表达式。global定义全局命名空间(global namespace),locals定义局部命名空间(locals namespace)。若没有locals参数，则使用globals定义值。若没有globals与locals参数，则使用单元本身的命名空间

exec string [in globals[,locals]]

运行包含Python程序代码的字符串string，globals与locals分别定义全局命名空间与局部命名空间

id(object)

返回object对象的唯一识别码，此识别码为一整数

>>> t = 9

>>> id(t)

1639045424

int(x[, radix])

x为数值/字符串,若是字符串，可以设置radix值。radix是进制的基底值，可以是[2,36]之间的整数或0.若radix是0，则Python会根据字符串值进行判断。radix是用来说明x是几进制数

>>> int(100.5)

100

>>> int("100",8)

64

>>> int("100",16)

256

>>> int("100",0)

100

max(s[,args...])

若只有一个参数，返回序数对象s中元素的最大值。如果有多个参数，返回最大的序数

>>> max(1,2,3,5,9)

9

>>> max("I love you !")

'y'

>>>max((1,2,3),(2,3),(1,2,4))

(2, 3)

min(s[,args...])

若只有一个参数，返回序数对象s中元素的最小值。若有多个参数，返回最小的序数

>>> min(1,2,3,5,9)

1

>>> min("I love you !")

' '

>>>min((1,2,3),(2,3),(1,2,4))

(1, 2, 3)

ord(c)

返回单字符字符串c的ASCII或Unicode字符。若c是ASCII字符，ord()函数与chr()函数作用相反；若c是Unicode字符，ord()函数与unichr()函数作用相反

>>> ord("♥")

9829

>>> chr(9829)

'♥'

pow(x, y[, z])

若没有参数z返回x^y，如果有z，则返回x^y % z,y不能是负数

>>> pow(2,4)

16

>>> pow(2,4,5)

1

>>> pow(2,-1)

0.5

tuple(sequence)

使用sequence来创建一个元组对象。若sequence本身就是一个元组，其值不变

>>> tuple("love")

('l', 'o', 'v', 'e')

>>> tuple(['l', 'o', 'v', 'e'])

('l', 'o', 'v', 'e')

%y

两位数的年份表示（00-99）

%Y

四位数的年份表示（000-9999）

%m

月份（01-12）

%d

月内中的一天（0-31）

%H

24小时制小时数（0-23）

%I

12小时制小时数（01-12）

%M

分钟数（00=59）

%S

秒（00-59）

%a

本地简化星期名称

%A

本地完整星期名称

%b

本地简化的月份名称

%B

本地完整的月份名称

%c

本地相应的日期表示和时间表示

%j

年内的一天（001-366）

%p

本地A.M.或P.M.的等价符

%U

一年中的星期数（00-53）星期天为星期的开始

%w

星期（0-6），星期天为星期的开始

%W

一年中的星期数（00-53）星期一为星期的开始

%x

本地相应的日期表示

%X

本地相应的时间表示

%Z

当前时区的名称

%%

%号本身