python基础知识总结

迈不过友情╰ 2023-02-16 06:48 38阅读 0赞

**注释：**

单行注释以 \# 开头

print ("Hello, Python!") \# 第一个注释

多行注释可以用 ''' 和 """

'''

第二注释

第三注释

'''

"""

第四注释

第五注释

"""

**Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字**

>>> import keyword

>>> keyword.kwlist

\['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else',

'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or',

'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'\]

**标识符**

第一个字符必须是字母表中字母或下划线 \_ 。

标识符的其他的部分由字母、数字和下划线组成。

标识符对大小写敏感。

**行与缩进**

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 \{\} 。

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数

if True:

print ("True")

else:

print ("False")

最后一行语句缩进数的空格数不一致，会导致运行错误

**多行语句**

通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠(\\)来实现多行语句

total = item\_one + \\

item\_two + \\

item\_three

在 \[\], \{\}, 或 () 中的多行语句，不需要使用反斜杠(\\)

**字符串(String)**

python中单引号和双引号使用完全相同。

使用三引号('''或""")可以指定一个多行字符串。

转义符 '\\'

按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。

字符串可以用 + 运算符连接在一起，用 \* 运算符重复，紧跟的数字为复制的次数。

Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。

Python中的字符串不能改变。

Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。

字符串的截取的语法格式如下：变量\[头下标:尾下标\]

str = 'Runoob'

str\[0:-1\] 截取第一个到倒数第二个的所有字符

str\[2:\] 截取从第三个开始往后的所有字符

★字符串前面使用**r**可以让反斜杠不发生转义。 如 r"this is a line with \\n" 则\\n会显示，并不是换行。

★包含中文的字符串前面使用**u**，使字符串已Unicode格式编码，防止因源码存储格式问题出现乱码

★字符串前面加**d**，标识字符串是bytes类型

**空行**

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

**记住**：空行也是程序代码的一部分。

**Python可以在同一行中使用多条语句，语句之间使用分号(;)分割**

import sys; x = 'runoob'; sys.stdout.write(x + '\\n')

**等待用户输入**

input("\\n\\n按下 enter 键后退出。")

以上代码中 ，"\\n\\n"在结果输出前会输出两个新的空行。一旦用户按下 enter 键时，程序将退出。

**print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""****或 ,**

**import 与 from...import**

在 python 用 import 或者 from...import 来导入相应的模块。

将整个模块(somemodule)导入，格式为： import somemodule

从某个模块中导入某个函数,格式为： from somemodule import somefunction

从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

将某个模块中的全部函数导入，格式为： from somemodule import \*

**设置编码**

Python默认编码格式 ：ASCII ，无法读取中文

解决方法：在文件开头加入 **\# -\*- coding: UTF-8 -\*-** 或者 **\#coding=utf-8**

***注意：******\#coding=utf-8**** 的 ****=**** 号两边不要空格。*

**多个语句构成代码组**

缩进相同的一组语句构成一个代码块，称之代码组。

像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。

我们将首行及后面的代码组称为一个子句(clause)。

如下实例：

if expression :

suite elif expression :

suite  else :

suite

**变量不需要声明**

Python 中的变量不需要声明（不需要声明变量的类型）。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建

counter = 100 \# 整型变量

miles = 1000.0 \# 浮点型变量

name = "runoob" \# 字符串

允许同时为多个变量赋值：

a = b = c = 1;

a,b,c = 1,2,”runoob” 即：a = 1;b = 2;c = “runoob”

一个变量可以通过赋值指向不同类型的对象

**标准数据类型**

六个标准的数据类型：

Number（数字）

String（字符串）

List（列表）

Tuple（元组）

Set（集合）

Dictionary（字典）

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；

可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

Python 字符串不能被改变。向一个索引位置赋值，比如word\[0\] = 'm'会导致错误

**python中数字有四种类型：整数、布尔型、浮点数和复数。**

int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

bool (布尔), 如 True。

float (浮点数), 如 1.23、3E-2

complex (复数), 如 1 + 2j、 1.1 + 2.2j

** ****type()** 函数可以用来查询变量所指的对象类型

还可以用 **isinstance** 来判断：

a = 111

isinstance(a, int) 返回True

isinstance 和 type 的区别在于：type()不会认为子类是一种父类类型，isinstance()会认为子类是一种父类类型。

***注意：******在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。***

**列表**

列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 \[\] 之间、用逗号分隔开的元素列表

和字符串一样，列表同样可以被索引和截取：变量 \[ 头下标 ： 尾下标 \]

索引值以 0 为开始值，-1 为从末尾的开始位置。

加号 **+** 是列表连接运算符，星号 **\*** 是重复操作。如下实例：

list = \[ 'abcd', 786 , 2.23, 'runoob', 70.2 \]

tinylist = \[123, 'runoob'\]

print (tinylist \* 2) \# 输出两次列表

print (list + tinylist) \# 连接列表

输出结果：

\[123, 'runoob', 123, 'runoob'\]

\['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob'\]

List中的元素是可以改变的

Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：变量 \[ 头下标 ： 尾下标：步长 \]

list = \[ 'abcd', 786 , 2.23, 'runoob', 70.2 \]

print (list\[1:4:2\]) \# 输出两次列表

输出结果：

\[786,’runoob’\]

**列表顺序翻转：**

list = \[ 'abcd', 786 , 2.23\]

List = list\[-1::-1\]

print(list)

输出结果：\[2.23,786,’abcd’\]

**切割字符串：跟Java一样，返回列表**

split()

**组合字符串：**

list = \[ 'abcd', 786 , 2.23\]

out = ‘ ’.join(list)

print(out)

输出结果：abcd 786 2.23

**Tuple（元组）**

元组（tuple）与列表类似，元组中的元素类型也可以不相同，不同之处在于元组的元素不能修改。元组写在小括号 **()** 里，元素之间用逗号隔开。

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )

tuple的元素不可改变，但它可以包含可变的对象，比如list列表

元组也使用+操作符进行拼接、\*重复

**Set（集合）**

基本功能是进行成员关系测试和删除重复元素。（set集合跟Java一样可以去重）

使用大括号 **\{ \}** 或者 **set()** 函数创建集合，注意：创建一个空集合必须用** set()** 而不是 **\{ \}**，因为 **\{ \}** 是用来创建一个空字典。

创建格式：

parame = \{value01,value02,...\}

或者set(value)：

set('abracadabra')

set可以进行集合运算

**示例 ：**

a = set('abracadabra')

b = set('alacazam')

print(a) print(a - b)  \# a 和 b 的差集

print(a | b)  \# a 和 b 的并集

print(a & b)  \# a 和 b 的交集

print(a ^ b)  \# a 和 b 中不同时存在的元素

输出结果：

\{'b', 'a', 'c', 'r', 'd'\}

\{'b', 'd', 'r'\}

\{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'\}

\{'a', 'c'\}

\{'l', 'r', 'z', 'm', 'b', 'd'\}

**Dictionary（字典）**

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。**相当于map**

字典是一种映射类型，字典用 **\{ \}** 标识，它是一个无序的 **键(key) : 值(value)** 的集合。

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

在同一个字典中，键(key)必须是唯一的。

**创建字典：**

tinydict = \{ 'name': 'runoob','code':1, 'site': 'www.runoob.com'\}

dict = \{\}

dict\['one'\] = "1 - 菜鸟教程"

dict\[2\] = "2 - 菜鸟工具"

**构造函数 dict() 可以直接从键值对序列中构建字典如下：**

dict(\[('Runoob', 1), ('Google', 2), ('Taobao', 3)\])

及：\{ 'Taobao': 3, 'Runoob': 1, 'Google': 2\}

\{ x: x\*\*2 for x in (2, 4, 6)\}

及：\{ 2: 4, 4: 16, 6: 36\}

dict(Runoob=1, Google=2, Taobao=3)

及：\{ 'Runoob': 1, 'Google': 2, 'Taobao': 3\}

**示例 ：**

tinydict = \{ 'name': 'runoob','code':1, 'site': 'www.runoob.com'\}

print (tinydict) \# 输出完整的字典

print (tinydict.keys()) \# 输出所有键

print (tinydict.values()) \# 输出所有值

输出结果：

\{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'\}

dict\_keys(\['name', 'code', 'site'\])

dict\_values(\['runoob', 1, 'www.runoob.com'\])

**Python数据类型转换**

数据类型的转换，只需要将数据类型作为函数名即可

<table style="margin-left:1.65pt;width:459pt;"> 
 <tbody> 
 <tr> 
 <td style="width:128.35pt;"> <a href="https://www.runoob.com/python3/python-func-int.html" rel="nofollow">int(x [,base])</a> </td> 
 <td style="width:330.65pt;"> 将x转换为一个整数 </td> 
 </tr> 
 <tr> 
 <td style="width:128.35pt;"> <a href="https://www.runoob.com/python3/python-func-float.html" rel="nofollow">float(x)</a> </td> 
 <td style="width:330.65pt;"> 将x转换到一个浮点数 </td> 
 </tr> 
 <tr> 
 <td style="width:128.35pt;"> <a href="https://www.runoob.com/python3/python-func-complex.html" rel="nofollow">complex(real [,imag])</a> </td> 
 <td style="width:330.65pt;"> 创建一个复数 </td> 
 </tr> 
 <tr> 
 <td style="width:128.35pt;"> <a href="https://www.runoob.com/python3/python-func-str.html" rel="nofollow">str(x)</a> </td> 
 <td style="width:330.65pt;"> 将对象 x 转换为字符串 </td> 
 </tr> 
 <tr> 
 <td style="width:128.35pt;"> <a href="https://www.runoob.com/python3/python-func-repr.html" rel="nofollow">repr(x)</a> </td> 
 <td style="width:330.65pt;"> 将对象 x 转换为表达式字符串 </td> 
 </tr> 
 <tr> 
 <td style="width:128.35pt;"> <a href="https://www.runoob.com/python3/python-func-eval.html" rel="nofollow">eval(str)</a> </td> 
 <td style="width:330.65pt;"> 用来计算在字符串中的有效Python表达式,并返回一个对象 </td> 
 </tr> 
 <tr> 
 <td style="width:128.35pt;"> <a href="https://www.runoob.com/python3/python3-func-tuple.html" rel="nofollow">tuple(s)</a> </td> 
 <td style="width:330.65pt;"> 将序列 s 转换为一个元组 </td> 
 </tr> 
 <tr> 
 <td style="width:128.35pt;"> <a href="https://www.runoob.com/python3/python3-att-list-list.html" rel="nofollow">list(s)</a> </td> 
 <td style="width:330.65pt;"> 将序列 s 转换为一个列表 </td> 
 </tr> 
 <tr> 
 <td style="width:128.35pt;"> <a href="https://www.runoob.com/python3/python-func-set.html" rel="nofollow">set(s)</a> </td> 
 <td style="width:330.65pt;"> 转换为可变集合 </td> 
 </tr> 
 <tr> 
 <td style="width:128.35pt;"> <a href="https://www.runoob.com/python3/python-func-dict.html" rel="nofollow">dict(d)</a> </td> 
 <td style="width:330.65pt;"> 创建一个字典。d 必须是一个序列 (key,value)元组。 </td> 
 </tr> 
 <tr> 
 <td style="width:128.35pt;"> <a href="https://www.runoob.com/python3/python-func-frozenset.html" rel="nofollow">frozenset(s)</a> </td> 
 <td style="width:330.65pt;"> 转换为不可变集合 </td> 
 </tr> 
 <tr> 
 <td style="width:128.35pt;"> <a href="https://www.runoob.com/python3/python-func-chr.html" rel="nofollow">chr(x)</a> </td> 
 <td style="width:330.65pt;"> 将一个整数转换为一个字符 </td> 
 </tr> 
 <tr> 
 <td style="width:128.35pt;"> <a href="https://www.runoob.com/python3/python-func-ord.html" rel="nofollow">ord(x)</a> </td> 
 <td style="width:330.65pt;"> 将一个字符转换为它的整数值 </td> 
 </tr> 
 <tr> 
 <td style="width:128.35pt;"> <a href="https://www.runoob.com/python3/python-func-hex.html" rel="nofollow">hex(x)</a> </td> 
 <td style="width:330.65pt;"> 将一个整数转换为一个十六进制字符串 </td> 
 </tr> 
 <tr> 
 <td style="width:128.35pt;"> <a href="https://www.runoob.com/python3/python-func-oct.html" rel="nofollow">oct(x)</a> </td> 
 <td style="width:330.65pt;"> 将一个整数转换为一个八进制字符串 </td> 
 </tr> 
 </tbody> 
</table>

**del语句删除对象**

使用del语句删除单个或多个对象。例如：

del var

del var\_a, var\_

**数值运算**

5 + 4 \# 加法

4.3 - 2 \# 减法

2.3

3 \* 7 \# 乘法

2 / 4 \# 除法，得到一个浮点数

0.5

17 % 3 \# 取余

2 // 4 \# 除法，得到一个整数

2 \*\* 5 \# 乘方

在混合计算时，Python会把整型转换成为浮点数。

**Python位运算符**

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

下表中变量 a 为 60，b 为 13二进制格式如下：

a = 0011 1100

b = 0000 1101

\-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

**Python逻辑运算符**

and、 or、 not：

x and y 布尔与

x or y 布尔或

not x 布尔非

a = 0

b = 20

if ( a and b ):

print ("3 - 变量 a 和 b 都为 true")

else:

print ("3 - 变量 a 和 b 有一个不为 true")

if ( a or b ):

print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")

else:

print ("4 - 变量 a 和 b 都不为 true")

if not( a and b ):

print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")

else:

print ("5 - 变量 a 和 b 都为 true")

3 - 变量 a 和 b 有一个不为 true

4 - 变量 a 和 b 都为 true，或其中一个变量为 true

5 - 变量 a 和 b 都为 false，或其中一个变量为 false

**Python成员运算符**

<table style="margin-left:1.65pt;width:491pt;"> 
 <tbody> 
 <tr> 
 <td style="width:50.5pt;"> in </td> 
 <td style="width:440.5pt;"> 如果在指定的序列中找到值返回 True，否则返回 False。 </td> 
 </tr> 
 <tr> 
 <td style="width:50.5pt;"> not in </td> 
 <td style="width:440.5pt;"> 如果在指定的序列中没有找到值返回 True，否则返回 False。 </td> 
 </tr> 
 </tbody> 
</table>

a = 10

b = 20

list = \[1, 2, 3, 4, 5 \];

if ( a in list ):

print ("1 - 变量 a 在给定的列表中 list 中")

else:

print ("1 - 变量 a 不在给定的列表中 list 中")

if ( b not in list ):

print ("2 - 变量 b 不在给定的列表中 list 中")

else:

print ("2 - 变量 b 在给定的列表中 list 中")

输出结果：

1 - 变量 a 不在给定的列表中 list 中

2 - 变量 b 不在给定的列表中 list 中

**Python身份运算符**

身份运算符用于比较两个对象的存储单元

<table style="margin-left:3.15pt;width:487pt;"> 
 <tbody> 
 <tr> 
 <td style="width:48.7pt;"> 运算符 </td> 
 <td style="width:143.5pt;"> 描述 </td> 
 <td style="width:294.8pt;"> 实例 </td> 
 </tr> 
 <tr> 
 <td style="width:48.7pt;"> is </td> 
 <td style="width:143.5pt;"> is 是判断两个标识符是不是引用自一个对象 </td> 
 <td style="width:294.8pt;"> x is y, 类似&nbsp;id(x) == id(y)&nbsp;, 如果引用的是同一个对象则返回 &nbsp;True，否则返回 False </td> 
 </tr> 
 <tr> 
 <td style="width:48.7pt;"> is not </td> 
 <td style="width:143.5pt;"> is not 是判断两个标识符是不是引用自不同对象 </td> 
 <td style="width:294.8pt;"> x is not y&nbsp;， 类似&nbsp;id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。 </td> 
 </tr> 
 </tbody> 
</table>

**注：** [id()][id] 函数用于获取对象内存地址。

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

**字符串前加u,r,b的含义**

**u:表示unicode字符串。**

防止字符串乱码

在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。   
在Python3中，所有的字符串都是Unicode字符串。

**r:表示原始字符串(忽略转义字符)**

print("abc\\n")

print(r"abc\\n")

输出：   
abc   
abc\\n

**b:表示bytes**

print("abc")

print(type("abc"))

print(type(b"abc"))

输出：

abc  
< class ‘str’>  
< class ‘bytes’>

# **[re.compile 函数][re.compile]** #

re模块中包含一个重要函数是compile(pattern \[, flags\]) ，该函数根据包含的正则表达式的字符串创建**模式对象**。可以实现更有效率的匹配。在直接使用字符串表示的正则表达式进行search,match和findall操作时，python会将字符串转换为正则表达式对象。而使用compile完成一次转换之后，在每次使用模式的时候就不用重复转换。当然，使用re.compile()函数进行转换后，re.search(pattern, string)的调用方式就转换为 pattern.search(string)的调用方式。

import re

some\_text = 'a,b,,,,c d'

reObj = re.compile('\[, \]+')

reObj.split(some\_text)

输出：

\['a', 'b', 'c', 'd'\]

**不使用re.compile**

在进行search,match等操作前不适用compile函数，会导致重复使用模式时，需要对模式进行重复的转换。降低匹配速度

import re

some\_text = 'a,b,,,,c d'

re.split('\[, \]+',some\_text)

输出：