基础知识

等待用户输入

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

同一行显示多条语句

Python 可以在同一行中使用多条语句，语句之间使用分号 ; 分割，以下是一个简单的实例：

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

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

1
2
3
4
5
6
7
8
9
10
11
x="a"
y="b"
# 换行输出
print( x )
print( y )
 
print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()

模块导入

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

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
x="a"
y="b"
# 换行输出
print( x )
print( y )
 
print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()

基本数据类型

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

在 Python 中，变量就是变量，它没有类型，我们所说的”类型”是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

1
2
3
4
5
6
7
counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串

print (counter)
print (miles)
print (name)

多个变量赋值
Python允许你同时为多个变量赋值

1
2
3
4
#三个变量被赋予相同的数值
a = b = c = 1
#也可以为多个对象指定多个变量
a, b, c = 1, 2, "runoob"

标准数据类型

Python3 中常见的数据类型有：

  • Number（数字）
  • String（字符串）
  • bool（布尔类型）
  • List（列表）
  • Tuple（元组）
  • Set（集合）
  • Dictionary（字典）

Python3 的六个标准数据类型中：

  • 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
  • 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）

    此外还有一些高级的数据类型，如: 字节数组类型(bytes)。

数字(Number)类型

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

  • int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
  • bool (布尔), 如 True。
  • float (浮点数), 如 1.23、3E-2
  • complex (复数), 如 1 + 2j、 1.1 + 2.2j
1
2
3
4
 a = 111
 print(isinstance(a, int))

>>>True

isinstance 和 type 的区别在于：

  • type()不会认为子类是一种父类类型。
  • isinstance()会认为子类是一种父类类型。

注意：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0 会返回 True，但可以通过 is 来判断类型。

一些操作

1
2
3
4
5
6
#当你指定一个值时，Number 对象就会被创建：
var1 = 1
var2 = 10
#可以通过使用del语句删除单个或多个对象
del var
del var_a, var_b

数值运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> 5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32

字符串(String)

  • Python 中单引号 ‘ 和双引号 “ 使用完全相同。
  • 使用三引号(‘’’ 或 “””)可以指定一个多行字符串。
  • 转义符 \。
  • 反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。 如 r”this is a line with \n” 则 \n 会显示，并不是换行。
  • 按字面意义级联字符串，如 “this “ “is “ “string” 会被自动转换为 this is string。
  • 字符串可以用 + 运算符连接在一起，用 * 运算符重复。
  • Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
  • Python 中的字符串不能改变。
  • Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
  • 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 #!/usr/bin/python3

str = 'Runoob'

print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符
print (str * 2)      # 输出字符串两次，也可以写成 print (2 * str)
print (str + "TEST") # 连接字符串

>>> Runoob
>>> Runoo
>>> R
>>> noo
>>> noob
>>> RunoobRunoob
>>> RunoobTEST

bool（布尔类型）

布尔类型即 True 或 False。

在 Python 中，True 和 False 都是关键字，表示布尔值。

布尔类型可以用来控制程序的流程，比如判断某个条件是否成立，或者在某个条件满足时执行某段代码。

布尔类型特点：

  • 布尔类型只有两个值：True 和 False。

  • 布尔类型可以和其他数据类型进行比较，比如数字、字符串等。在比较时，Python 会将 True 视为 1，False 视为 0。

  • 布尔类型可以和逻辑运算符一起使用，包括 and、or 和 not。这些运算符可以用来组合多个布尔表达式，生成一个新的布尔值。

  • 布尔类型也可以被转换成其他数据类型，比如整数、浮点数和字符串。在转换时，True 会被转换成 1，False 会被转换成 0。

List（列表）

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

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

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

变量[头下标:尾下标]

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 #!/usr/bin/python3

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']

print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表

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

以下实例用于翻转字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def reverseWords(input):
     
    # 通过空格将字符串分隔符，把各个单词分隔为列表
    inputWords = input.split(" ")
 
    # 翻转字符串
    # 假设列表 list = [1,2,3,4],  
    # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
    # inputWords[-1::-1] 有三个参数
    # 第一个参数 -1 表示最后一个元素
    # 第二个参数为空，表示移动到列表末尾
    # 第三个参数为步长，-1 表示逆向
    inputWords=inputWords[-1::-1]
 
    # 重新组合字符串
    output = ' '.join(inputWords)
     
    return output
 
if __name__ == "__main__":
    input = 'I like runoob'
    rw = reverseWords(input)
    print(rw)

列表常用方法

List 内置了有很多方法，例如 append()、pop() 等：

  • List.append(x)：在列表末尾添加一个元素
  • List.extend([x,y,…])：在列表后扩展一个列表
  • List.insert(x,y)：在序号x位置处添加元素y
  • List.pop(x)：弹出序号x位置处的元素
  • List.clear()：清空列表
  • List.sort()：将元素从小到大排序
  • List.reverse()：将元素从大到小排序，效果等同于List.sort(reverse=True)
  • List.count(x)：查找列表中元素x的数量
  • List.index(x)：查找列表中元素x的位置
  • List.copy：拷贝

因为列表可变，赋值的方式本质是让不同的变量指向同一个对象列表，而列表是可变的，这样会让在改变其中一个列表的值同时改动了其他列表

浅拷贝(两种形式)

  1. list_copy1 = list.copy
  2. list_copy2 = list[:]

浅拷贝只能拷贝外层的对象，列表多层嵌套时只能拷贝到其引用，此时要使用深拷贝

深拷贝(要引用py的copy库)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import copy 
#浅拷贝
x = [[1,2,3]，[4,5,6]，[7,8,9]]
y = copy.copy(x)
x[1][1] = 0
# >>> x
# [[1,2,3]，[4,0,6]，[7,8,9]]
# >>> y
# [[1,2,3]，[4,0,6]，[7,8,9]]

#深拷贝
x = [[1,2,3]，[4,5,6]，[7,8,9]]
y = copy.deepcopy(x)
x[1][1] = 0
# >>> x
# [[1,2,3]，[4,0,6]，[7,8,9]]
# >>> y
# [[1,2,3]，[4,5,6]，[7,8,9]]

列表推导式

形式：**[expression for target in iterable]**

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#原循环
oho = [1,2,3,4,5]
for i in range(len(oho)):
    oho[i] = oho[i]*2
>>>oho
[2, 4, 6, 8, 10]

#现列表推导式
oho = [1,2,3,4,5]
oho=[i*2 for i in range(len(oho))]
>>>oho
[2, 4, 6, 8, 10]

matrix = [[1,2,3],
          [4,5,6],
          [7,8,9]]
col2  =[row[1] for row in range(len(matrix))]
>>>col2
[2, 5, 8]

diag1 =[matrix[i][i] for i in range(len(matrix))]
>>>diag1
[1, 5, 9]

diag2 =[matrix[i][2-i] for i in range(len(matrix))]
>>>diag2
[3, 5, 7]

利用列表推导式创建嵌套列表
s= [ [0]*3 for i in range(3) ]

为列表推导式增加条件

形式：**[expression for target in iterable if condition]**

1
2
3
4
5
6
7
8
9
10
11
12
even = [i for i in range(10) if i % 2 == 0]
>>>even
[0, 2, 4, 6，8]

odd = [i+1 for i in range(10) if i % 2 == 0]
>>>odd
[1, 3, 5，8, 9]

words = ["Great","FishC","Brilliant","Excellent","Fantistic"]fwords = [w for w in words if w[0] =='F']
>>>fwords
["FishC","Fantistic"]

Tuple（元组）

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

元组中的元素类型也可以不相同： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#!/usr/bin/python3

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

print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的所有元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 连接元组

>>> ('abcd', 786, 2.23, 'runoob', 70.2)
>>> abcd
>>> (786, 2.23)
>>> (2.23, 'runoob', 70.2)
>>> (123, 'runoob', 123, 'runoob')
>>> ('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。

其实，可以把字符串看作一种特殊的元组。 修改元组元素的操作是非法的

建立一个只有一个元素的元组： x=(520,),其中逗号很关键

打包和解包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#打包
t = (123，"Fishc"，3.14)
>>>t
(123，'FishC'，3.14)

#解包
x，y，z= t
>>>X
123

>>> y
'FishC

>>> Z
3.14

其他序列类型也可以实现打包和解包

1
2
3
4
5
6
7
a,b,c,d,e="FishC'
>>>c
's'

a,b,*c="FishC'
>>>c
['s','h','C']

Set（集合）

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

基本功能是进行成员关系测试和删除重复元素。

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

创建格式：

  • parame = {value01,value02,…}
  • set(value)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#!/usr/bin/python3

sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}

print(sites)   # 输出集合，重复的元素被自动去掉

# 成员测试
if 'Runoob' in sites :
    print('Runoob 在集合中')
else :
    print('Runoob 不在集合中')


# 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 中不同时存在的元素

>>> {'Zhihu', 'Baidu', 'Taobao', 'Runoob', 'Google', 'Facebook'}
>>> Runoob 在集合中
>>> {'b', 'c', 'a', 'r', 'd'}
>>> {'r', 'b', 'd'}
>>> {'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}
>>> {'c', 'a'}
>>> {'z', 'b', 'm', 'r', 'l', 'd'}

Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型。

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#!/usr/bin/python3

dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"

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


print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

>>> 1 - 菜鸟教程
>>> 2 - 菜鸟工具
>>> {'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
>>> dict_keys(['name', 'code', 'site'])
>>> dict_values(['runoob', 1, 'www.runoob.com'])

注意：

1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用 { }。

Python数据类型转换

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

函数 描述
int(x [,base]) 将x转换为一个整数
float(x) 将x转换到一个浮点数
complex(real [,imag]) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) 转换为可变集合
dict(d) 建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串

Python成员运算符&身份运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符 描述 实例
in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

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

运算符 描述 实例
is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 id(x) != id(y)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

条件控制

Python 中用elif代替了 else if，所以if语句的关键字为：if – elif – else。

注意：

1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。

2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。

3、在 Python 中没有 switch…case 语句，但在 Python3.10 版本添加了 match…case，功能也类似。

1
2
3
4
5
6
7
8
9
10
11
12
13
mystatus=400
print(http_error(400))

def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "I'm a teapot"
        case _:
            return "Something's wrong with the internet"

一个 case 也可以设置多个匹配条件，条件使用 ｜ 隔开，例如：

1
2
3
...
    case 401|403|404:
        return "Not allowed"