Python编程知识点总结

最新推荐文章于 2022-04-30 12:57:50 发布
最新推荐文章于 2022-04-30 12:57:50 发布
阅读量2.2k 收藏 15
点赞数 2
文章标签： python
原文链接：https://www.runoob.com/python3/python3-tutorial.html
版权

Python编程知识点总结

文章目录

一、基础语法

-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中单行注释以 # 开头，
多行注释用多个 # 号，还有 ‘’’ 和 “”"：


#第一个注释
#第二个注释
 
'''
第三注释
第四注释
'''
 
"""
第五注释
第六注释
"""
print ("Hello, Python!")

执行以上代码，输出结果为

Hello, Python!
-行与缩进

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。
缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。*实例如下：

if True:
    print ("True")
else:
    print ("False")

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

if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")
  print ("False")    # 缩进不一致，会导致运行错误

以上程序由于缩进不一致，执行后会出现类似以下错误：

 File "test.py", line 6
    print ("False")    # 缩进不一致，会导致运行错误
                                      ^
IndentationError: unindent does not match any outer indentation level
-三种基本数据类型
1. 数字(Number)类型

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

  1. int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
  2. bool (布尔), 如 True。
  3. float (浮点数), 如 1.23、3E-2
  4. complex (复数), 如 1 + 2j、 1.1 + 2.2j
2. 字符串(String)
  • python中单引号和双引号使用完全相同。
  • 使用三引号(’’'或""")可以指定一个多行字符串。
  • 转义符 ’ \ ’
  • 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示，并不是换行。
  • 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
  • 字符串可以用 +运算符连接在一起，用 * 运算符重复。
  • Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
  • Python中的字符串不能改变。
  • Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
  • 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]
word = '字符串'
sentence = "这是一个句子。"
paragraph = """这是一个段落，

实例：

可以由多行组成"""str='Runoob'
print(str)                 # 输出字符串
print(str[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str[0])              # 输出字符串第一个字符
print(str[2:5])            # 输出从第三个开始到第五个的字符
print(str[2:])             # 输出从第三个开始后的所有字符
print(str * 2)             # 输出字符串两次
print(str + '你好')        # 连接字符串

print('------------------------------')

print('hello\nrunoob')      # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义这里的 r 指 raw，即 raw string。输出结果为：Runoob
Runoo
R
noo
noob
RunoobRunoob
Runoob你好
------------------------------
hello
runoob
hello\nrunoob
3. 布尔类型
-Python数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

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

函数描述
int(x,base)将x转换为一个整数 (base表示进制数，默认10进制)
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)将一个整数转换为一个八进制字符串
-import 与 from…import

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

将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *

导入 sys 模块 
import sys
print('================Python import mode==========================')
print ('命令行参数为:')
for i in sys.argv:
    print (i)
print ('\n python 路径为',sys.path)



导入 sys 模块的 argv,path 成员 

from sys import argv,path  #  导入特定的成员
 
print('================python from import===================================')
print('path:',path) # 因为已经导入path成员，所以此处引用时不需要加sys.path
-运算符
1. 算术运算符

在这里插入图片描述

2. 比较（关系）运算符

在这里插入图片描述

3. 赋值运算符

在这里插入图片描述

4. 逻辑运算符

在这里插入图片描述

5. 位运算符

在这里插入图片描述

-运算符的优先级

在这里插入图片描述

二、程序控制结构

-程序的流程图

程序流程图用一系列图形、流程线和文字说明描述程序的基本操作和控制流程，他是程序分析和过程描述的最基本方式。

  • 流程图的七种基本元素：
    在这里插入图片描述
    程序流程图示例： 由连接点A连接的一个程序
    在这里插入图片描述
-程序的基本结构
1. 顺序结构：

是程序按照线性顺序依次执行的一种运行方式，其中语句块S1和语句块S2表示一个或一组顺序执行的语句。
顺序结构是程序的基础，但单一的顺序结构不能解决所有问题。
在这里插入图片描述

2. 分支结构：

是程序根据条件判断结果而选择不同向前执行路径的一种运行方式，包括单分支结构和二分支结构。由二分支结构会组合形成多分支结构。

在这里插入图片描述

3.循环结构：

是程序根据条件判断结果向后反复执行的一种运行方式，根据循环体触发条件不同，包括条件循环和遍历循环结构。
在这里插入图片描述

-程序分支结构
1.单分支结构：

根据判断条件结果而选择不同向前路径的运行方式

if <条件> :
<语句块>
在这里插入图片描述

2.二分支结构:

根据判断条件结果而选择不同向前路径的运行方式

if <条件> :
<语句块1>
else :
<语句块2>
在这里插入图片描述

紧凑形式：

适用于简单表达式的二分支结构

<表达式1> if <条件> else <表达式2>

a = eval(input())
print("猜{}了".format("对" if a == 99 else "错"))
3.多分支结构

if <条件1> : <语句块1> elif <条件2> : <语句块2> …… else :
<语句块N>
在这里插入图片描述

-循环结构

Python 中的循环语句有for 和 while。
Python 循环语句的控制结构图如下所示：
在这里插入图片描述

1.while 循环

Python 中 while 语句的一般形式：

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

执行流程图如下：
在这里插入图片描述
执行 Gif 演示：
在这里插入图片描述
同样需要注意冒号和缩进。另外，在 Python 中没有 do…while 循环。
以下实例使用了 while 来计算 1 到 100 的总和：

实例#!/usr/bin/env python3
 
n = 100
 
sum = 0
counter = 1
while counter <= n:
    sum = sum + counter
    counter += 1
 
print("1 到 %d 之和为: %d" % (n,sum))

执行结果如下：

1 到 100 之和为: 5050
2.无限循环

我们可以通过设置条件表达式永远不为 false 来实现无限循环，实例如下：

实例#!/usr/bin/python3
 
var = 1
while var == 1 :  # 表达式永远为 true
   num = int(input("输入一个数字  :"))
   print ("你输入的数字是: ", num)
 
print ("Good bye!")

执行以上脚本，输出结果如下：

输入一个数字  :5
你输入的数字是:  5
输入一个数字  :

你可以使用CTRL+C来退出当前的无限循环。
无限循环在服务器上客户端的实时请求非常有用。

3.while 循环使用 else 语句

在 while … else 在条件语句为 false 时执行 else 的语句块。
语法格式如下：

while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>

循环输出数字，并判断大小：

实例#!/usr/bin/python3
 
count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")

执行以上脚本，输出结果如下：

0  小于 5
1  小于 5
2  小于 5
3  小于 5
4  小于 5
5  大于或等于 5
3.简单语句组

类似if语句的语法，如果你的while循环体中只有一条语句，你可以将该语句与while写在同一行中， 如下所示：

实例#!/usr/bin/python
 
flag = 1
 
while (flag): print ('欢迎访问我的博客!')
 
print ("Good bye!")

注意：以上的无限循环你可以使用 CTRL+C 来中断循环。执行以上脚本，输出结果如下：

欢迎访问我的博客!
欢迎访问我的博客!
欢迎访问我的博客!
欢迎访问我的博客!
欢迎访问我的博客!
……
4.for 语句

Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
for循环的一般格式如下：

for <variable> in <sequence>:
    <statements>
else:
    <statements>

流程图：
在这里插入图片描述
Python for 循环实例：

实例
>>>languages = ["C", "C++", "Perl", "Python"] 
>>> for x in languages:
...     print (x)
... 
C
C++
Perl
Python
>>>

以下 for实例中使用了 break 语句，break 语句用于跳出当前循环体：

实例#!/usr/bin/python3
 
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("菜鸟教程!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")

执行脚本后，在循环到 "Runoob"时会跳出循环体：
循环数据 Baidu
循环数据 Google
菜鸟教程!
完成循环!

5.range()函数

如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如:

实例>>>for i in range(5):
...     print(i)
...
0
1
2
3
4

你也可以使用range指定区间的值：

实例
>>>for i in range(5,9) :
    print(i)
     
     
5
6
7
8
>>>

也可以使range以指定数字开始并指定不同的增量(甚至可以是负数，有时这也叫做’步长’):

实例
>>>for i in range(0, 10, 3) :
    print(i)
     
0
3
6
9
>>>

负数：

实例
>>>for i in range(-10, -100, -30) :
    print(i)
 
    
-10
-40
-70
>>>

您可以结合range()和len()函数以遍历一个序列的索引,如下所示:

实例
>>>a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
>>> for i in range(len(a)):
...     print(i, a[i])
... 
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ
>>>

还可以使用range()函数来创建一个列表：

实例
>>>list(range(5))
[0, 1, 2, 3, 4]
>>>
6.break 和 continue 语句及循环中的 else 子句

break 执行流程图：
在这里插入图片描述
continue 执行流程图：
在这里插入图片描述
代码执行过程：
在这里插入图片描述
break语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
实例
while 中使用 break：

实例
n = 5
while n > 0:
    n -= 1
    if n == 2:
        break
    print(n)
print('循环结束。')

输出结果为：

4
3
循环结束。

while 中使用 continue：

实例
n = 5
while n > 0:
    n -= 1
    if n == 2:
        continue
    print(n)
print('循环结束。')

输出结果为：

4
3
1
0
循环结束。

以下实例循环字符串 Runoob，碰到字母 o 跳过输出：

实例#!/usr/bin/python3
 
for letter in 'Runoob':     # 第一个实例
   if letter == 'o':        # 字母为 o 时跳过输出
      continue
   print ('当前字母 :', letter)
 
var = 10                    # 第二个实例
while var > 0:              
   var = var -1
   if var == 5:             # 变量为 5 时跳过输出
      continue
   print ('当前变量值 :', var)
print ("Good bye!")

执行以上脚本输出结果为：

当前字母 : R
当前字母 : u
当前字母 : n
当前字母 : b
当前变量值 : 9
当前变量值 : 8
当前变量值 : 7
当前变量值 : 6
当前变量值 : 4
当前变量值 : 3
当前变量值 : 2
当前变量值 : 1
当前变量值 : 0
Good bye!

循环语句可以有 else子句，它在穷尽列表(以for循环)或条件变为false (以while循环)导致循环终止时被执行，但循环被 break 终止时不执行。如下实例用于查询质数的循环例子:

实例#!/usr/bin/python3
 
for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(n, '等于', x, '*', n//x)
            break
    else:
        # 循环中没有找到元素
       print(n, ' 是质数')

执行以上脚本输出结果为：

2  是质数
3  是质数
4 等于 2 * 2
5  是质数
6 等于 2 * 3
7  是质数
8 等于 2 * 4
9 等于 3 * 3
7.pass 语句

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

实例
>>>while True:
...     pass  # 等待键盘中断 (Ctrl+C)

最小的类:

实例
>>>class MyEmptyClass:
...     pass

以下实例在字母为 o 时 执行 pass 语句块:

实例#!/usr/bin/python3
 
for letter in 'Runoob': 
   if letter == 'o':
      pass
      print ('执行 pass 块')
   print ('当前字母 :', letter)
 
print ("Good bye!")

执行以上脚本输出结果为：

当前字母 : R
当前字母 : u
当前字母 : n
执行 pass 块
当前字母 : o
执行 pass 块
当前字母 : o
当前字母 : b
Good bye!

三、组合数据类型

1.列表

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
Python有6个序列的内置类型，但最常见的是列表和元组。
序列都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。

-访问列表中的值

使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：

实例(Python 3.0+)#!/usr/bin/python3
 
list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
 
print ("list1[0]: ", list1[0])
print ("list2[1:5]: ", list2[1:5])
以上实例输出结果：
list1[0]:  Google
list2[1:5]:  [2, 3, 4, 5]
-更新列表

你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示：

实例(Python 3.0+)#!/usr/bin/python3
 
list = ['Google', 'Runoob', 1997, 2000]
 
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])

注意：我们会在接下来的章节讨论append()方法的使用
以上实例输出结果：

第三个元素为 :  1997
更新后的第三个元素为 :  2001
-删除列表元素

可以使用 del 语句来删除列表的的元素，如下实例：

实例(Python 3.0+)#!/usr/bin/python3
 
list = ['Google', 'Runoob', 1997, 2000]
 
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)
以上实例输出结果：
原始列表 :  ['Google', 'Runoob', 1997, 2000]
删除第三个元素 :  ['Google', 'Runoob', 2000]

注意：我们会在接下来的章节讨论 remove() 方法的使用

-Python列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
如下所示：
在这里插入图片描述

-Python列表截取与拼接

Python的列表截取与字符串操作类型，如下所示：

L=[‘Google’, ‘Runoob’, ‘Taobao’]

操作：
在这里插入图片描述

>>>L=['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['Runoob', 'Taobao']
>>>

列表还支持拼接操作：

>>>squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>
-嵌套列表

使用嵌套列表即在列表里创建其它列表，例如：

>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'
-列表函数&方法

Python包含以下函数:
在这里插入图片描述
Python包含以下方法:
在这里插入图片描述

2.元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
实例(Python 3.0+)


>>>tup1 = ('Google', 'Runoob', 1997, 2000);
>>> tup2 = (1, 2, 3, 4, 5 );
>>> tup3 = "a", "b", "c", "d";   #  不需要括号也可以
>>> type(tup3)
<class 'tuple'>

创建空元组

tup1 = ();

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

实例(Python 3.0+)>>>tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>
 
>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

-访问元组

元组可以使用下标索引来访问元组中的值，如下实例:

实例(Python 3.0+)#!/usr/bin/python3
 
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

以上实例输出结果：

tup1[0]:  Google
tup2[1:5]:  (2, 3, 4, 5)
-修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

实例(Python 3.0+)#!/usr/bin/python3
 
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2;
print (tup3)

以上实例输出结果：

(12, 34.56, 'abc', 'xyz')
-删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

实例(Python 3.0+)#!/usr/bin/python3
 
tup = ('Google', 'Runoob', 1997, 2000)
 
print (tup)
del tup;
print ("删除后的元组 tup : ")
print (tup)

以上实例元组被删除后，输出变量会有异常信息，输出如下所示：

删除后的元组 tup : 
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (tup)
NameError: name 'tup' is not defined
-元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
在这里插入图片描述

-元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：
元组：

L = ('Google', 'Taobao', 'Runoob')Python

在这里插入图片描述
运行实例如下：

>>> L = ('Google', 'Taobao', 'Runoob')
>>>> L[2]
'Runoob'
>>> L[-2]
'Taobao'
>>> L[1:]
('Taobao', 'Runoob')
-元组内置函数

Python元组包含了以下内置函数：
在这里插入图片描述

-关于元组是不可变的

所谓元组的不可变指的是元组所指向的内存中的内同不可变。

>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g'     # 不支持修改元素
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(tup)     # 查看内存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800    # 内存地址不一样了

从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。

3.字典

字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。一个简单的字典实例：

 dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}也可如此创建字典：dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }
-访问字典里的值

把相应的键放入到方括号中，如下实例:

实例#!/usr/bin/python3
 
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])

以上实例输出结果：

dict['Name']:  Runoob
dict['Age']:  7

如果用字典里没有的键访问数据，会输出错误如下：

实例#!/usr/bin/python3
 
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("dict['Alice']: ", dict['Alice'])

以上实例输出结果：

Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print ("dict['Alice']: ", dict['Alice'])
KeyError: 'Alice'
-修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对，如下实例:

实例#!/usr/bin/python3
 
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
dict['Age'] = 8               # 更新 Age
dict['School'] = "菜鸟教程"  # 添加信息
 
 
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

以上实例输出结果：

 dict['Age']:  8
dict['School']:  菜鸟教程
-删除字典

元素能删单一的元素也能清空字典，清空只需一项操作。显示删除一个字典用del命令，如下实例：

实例#!/usr/bin/python3
 
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典
 
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

但这会引发一个异常，因为用执行 del 操作后字典不再存在：

Traceback (most recent call last):
  File "test.py", line 9, in <module>
    print ("dict['Age']: ", dict['Age'])
TypeError: 'type' object is not subscriptable
-字典键的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

实例#!/usr/bin/python3
 
dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}
 
print ("dict['Name']: ", dict['Name'])

以上实例输出结果：

dict['Name']:  小菜鸟

2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：

实例#!/usr/bin/python3
 
dict = {['Name']: 'Runoob', 'Age': 7}
 
print ("dict['Name']: ", dict['Name'])

以上实例输出结果：

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    dict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'
-字典内置函数&方法

Python字典包含了以下内置函数：
在这里插入图片描述
Python字典包含了以下内置方法：在这里插入图片描述在这里插入图片描述
在这里插入图片描述

4.集合

集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：

parame = {value01,value02,…}
或者
set(value)

实例(Python 3.0+)
>>>basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False
 
>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

类似列表推导式，同样集合支持集合推导式(Set comprehension):

实例(Python 3.0+)
>>>a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
-集合的基本操作

1、添加元素
语法格式如下：

s.add( x )

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

实例(Python 3.0+)>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：

s.update( x )

x 可以有多个，用逗号分开。

实例(Python 3.0+)>>>thisset = set(("Google", "Runoob", "Taobao"))

>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}
>>>

2、移除元素
语法格式如下：

s.remove( x )

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

实例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
>>>

此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：

s.discard( x )

实例(Python 3.0+)
>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}我们也可以设置随机删除集合中的一个元素，语法格式如下：s.pop() 脚本模式实例(Python 3.0+)thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()
print(x)

输出结果：

$ python3 test.py 
Runoob

多次执行测试结果都不一样。
set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

-计算集合元素个数

语法格式如下：

len(s)

计算集合 s 元素个数。

实例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> len(thisset)
3
-清空集合

语法格式如下：

s.clear()

清空集合 s

实例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()
-判断元素是否在集合中存在

语法格式如下：

x in s

判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

实例(Python 3.0+)
>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True
>>> "Facebook" in thisset
False
>>>
-集合内置方法完整列表

在这里插入图片描述

四、字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号( ’ 或 " )来创建字符串。
创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = ‘Hello World!’
var2 = “Runoob”

-Python 访问字符串中的值

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
Python 访问子字符串，可以使用方括号来截取字符串，如下实例：

实例(Python 3.0+) 
#!/usr/bin/python3

var1 = 'Hello World!'
var2 = "Runoob"
 
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])

以上实例执行结果：

var1[0]:  H
var2[1:5]:  unoo
-Python 字符串更新

你可以截取字符串的一部分并与其他字段拼接，如下实例：

 
实例(Python 3.0+) 

#!/usr/bin/python3
 
var1 = 'Hello World!'
 
print ("已更新字符串 : ", var1[:6] + 'Runoob!')

以上实例执行结果：

已更新字符串 :  Hello Runoob!
-Python转义字符

在需要在字符中使用特殊字符时，python用反斜杠()转义字符。如下表：
在这里插入图片描述

-Python字符串运算符

下表实例变量a值为字符串 “Hello”，b变量值为 “Python”：在这里插入图片描述

实例(Python 3.0+) 

#!/usr/bin/python3
 
a = "Hello"
b = "Python"
 
print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])
 
if( "H" in a) :
    print("H 在变量 a 中")
else :
    print("H 不在变量 a 中")
 
if( "M" not in a) :
    print("M 不在变量 a 中")
else :
    print("M 在变量 a 中")
 
print (r'\n')
print (R'\n')

以上实例输出结果为：

a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n
-Python字符串格式化

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

实例(Python 3.0+) 

#!/usr/bin/python3
 
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

以上实例输出结果：

我叫 小明 今年 10 岁!

python字符串格式化符号:在这里插入图片描述
格式化操作符辅助指令:在这里插入图片描述
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能
基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数，位置可以不按顺序。
实例:

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'
 >>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'
 >>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

也可以设置参数：
实例:

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
 
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
 
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

输出结果为：

网站名：菜鸟教程, 地址 www.runoob.com
网站名：菜鸟教程, 地址 www.runoob.com
网站名：菜鸟教程, 地址 www.runoob.com

也可以向 str.format() 传入对象：
实例:

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value))  # "0" 是可选的

输出结果为：

value 为: 6
-数字格式化

下表展示了 str.format() 格式化数字的多种方法：

>>> print("{:.2f}".format(3.1415926));
3.14

在这里插入图片描述
在这里插入图片描述
^,<, >分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。

此外我们可以使用大括号 {} 来转义大括号，如下实例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
print ("{} 对应的位置是 {{0}}".format("runoob"))

输出结果为：

runoob 对应的位置是 {0}
-Python三引号

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。实例如下

 
实例(Python 3.0+) 

#!/usr/bin/python3
 
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)

以上实例执行结果为：

这是一个多行字符串的实例
多行字符串可以使用制表符
TAB (    )。
也可以使用换行符 [ 
 ]。

三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。
一个典型的用例是，当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。

errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
cursor.execute('''
CREATE TABLE users (  
login VARCHAR(8), 
uid INTEGER,
prid INTEGER)
''')
-f-string

f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。
之前我们习惯用百分号 (%):

实例 
>>> name = 'Runoob'

>>> 'Hello %s' % name

'Hello Runoob'

f-string 格式话字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下：

实例 
>>> name = 'Runoob'
>>> f'Hello {name}'  # 替换变量
>>> f'{1+2}'         # 使用表达式
'3'
>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'

用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d。
在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：

实例 
>>> x = 1
>>> print(f'{x+1}')   # Python 3.6
2
>>> x = 1
>>> print(f'{x+1=}')   # Python 3.8
'x+1=2'
-Unicode 字符串

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

-Python 的字符串内建函数

Python 的字符串常用内建函数如下：在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

五、函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。
但你也可以自己创建函数，这被叫做用户自定义函数。

-定义一个函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

  • 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
  • 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
  • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
  • 函数内容以冒号起始，并且缩进。
  • return [表达式] 结束函数，选择性地返回一个值给调用方。
  • 不带表达式的return相当于返回 None。
-语法

Python 定义函数使用 def 关键字，一般格式如下：

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

默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。
实例
让我们使用函数来输出"Hello World！"：

>>>def hello() : 
   print("Hello World!")   


>>> hello()
Hello World!
>>>

更复杂点的应用，函数中带上参数变量:

实例(Python 3.0+)#!/usr/bin/python3
 
# 计算面积函数
def area(width, height):
    return width * height
 
def print_welcome(name):
    print("Welcome", name)
 
print_welcome("Runoob")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))

以上实例输出结果：

Welcome Runoob
width = 4  height = 5  area = 20
-函数调用

定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。
如下实例调用了printme() 函数：

实例(Python 3.0+)#!/usr/bin/python3
 
# 定义函数
def printme( str ):
   # 打印任何传入的字符串
   print (str)
   return
 
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

以上实例输出结果：

我要调用用户自定义函数!
再次调用同一函数
-参数传递

在 python 中，类型属于对象，变量是没有类型的：

a=[1,2,3]
a="Runoob"

以上代码中，[1,2,3] 是 List 类型，“Runoob” 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。

-可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

  • 不可变类型：
    变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了
  • 可变类型：
    变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

  • 不可变类型：
    类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
  • 可变类型：
    类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
    python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
-python 传不可变对象实例
实例(Python 3.0+)#!/usr/bin/python3
 
def ChangeInt( a ):
    a = 10
 
b = 2
ChangeInt(b)
print( b ) # 结果是 2

实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。

-传可变对象实例

可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如：

实例(Python 3.0+)#!/usr/bin/python3
 
# 可写函数说明
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)

传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下：

函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]
-参数

以下是调用函数时可使用的正式参数类型：

  • 必需参数
  • 关键字参数
  • 默认参数
  • 不定长参数
-必需参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用 printme() 函数，你必须传入一个参数，不然会出现语法错误：

实例(Python 3.0+)#!/usr/bin/python3
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
# 调用 printme 函数，不加参数会报错
printme()

以上实例输出结果：

Traceback (most recent call last):
  File "test.py", line 10, in <module>
    printme()
TypeError: printme() missing 1 required positional argument: 'str'
-关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名：

实例(Python 3.0+)#!/usr/bin/python3
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
#调用printme函数
printme( str = "你好世界")

以上实例输出结果：

你好世界

以下实例中演示了函数参数的使用不需要使用指定顺序：

实例(Python 3.0+)#!/usr/bin/python3
 
#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
 #调用printinfo函数
printinfo( age=50, name="runoob" )

以上实例输出结果：

名字:  runoob
年龄:  50
-默认参数

调用函数时，如果没有传递参数，则会使用默认参数。
以下实例中如果没有传入 age 参数，则使用默认值：

实例(Python 3.0+)#!/usr/bin/python3
 
#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

以上实例输出结果：

名字:  runoob
年龄:  50
------------------------
名字:  runoob
年龄:  35
-不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：

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

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

实例(Python 3.0+)#!/usr/bin/python3
  
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

以上实例输出结果：

输出: 
70
(60, 50)

如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例：

实例(Python 3.0+)#!/usr/bin/python3
 
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

以上实例输出结果：

输出:
10
输出:
70
60
50

还有一种就是参数带两个星号 **基本语法如下：

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

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

 实例(Python 3.0+)#!/usr/bin/python3
  
# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

以上实例输出结果：

输出: 
1
{'a': 2, 'b': 3}

声明函数时，参数中星号* 可以单独出现，例如:

def f(a,b, * ,c):
return a+b+c

如果单独出现星号 * 后的参数必须用关键字传入。

    >>> def f(a,b,*,c):
...     return a+b+c
... 

>>> f(1,2,3)   # 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6
>>>
-匿名函数

python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

  • lambda 只是一个表达式，函数体比 def 简单很多。
  • lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
  • lambda函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
  • 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
-语法

lambda 函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,…argn]]:expression

如下实例：

实例(Python 3.0+)#!/usr/bin/python3
 
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

以上实例输出结果：

相加后的值为 :  30
相加后的值为 :  40
return语句

return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，以下实例演示了 return 语句的用法：

实例(Python 3.0+)#!/usr/bin/python3
 
# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print ("函数内 : ", total)
   return total
 
# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)

以上实例输出结果：

函数内 :  30
函数外 :  30
强制位置参数

Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 或 f 要求为关键字形参:

def f(a, b, /, c, d, *, e, f):
print(a, b, c, d, e, f)

以下使用方法是正确的:

f(10, 20, 30, d=40, e=50, f=60)

以下使用方法会发生错误:

f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式 f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式

六、模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。
1、import sys 引入 python 标准库中的 sys.py 模块；这是引入某一模块的方法。
2、sys.argv 是一个包含命令行参数的列表。
3、sys.path 包含了一个 Python 解释器自动查找所需模块的路径的列表。

-import 语句

想使用 Python 源文件，只需在另一个源文件里执行 import 语句，语法如下：

import module1[, module2[,… moduleN]

当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。
搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support，需要把命令放在脚本的顶端：

support.py 文件代码 

#!/usr/bin/python3
# Filename: support.py
 
def print_func( par ):
    print ("Hello : ", par)
    return

test.py 引入 support 模块：

test.py 文件代码 

#!/usr/bin/python3
# Filename: test.py
 
# 导入模块
import support
 
# 现在可以调用模块里包含的函数了
support.print_func("Runoob")

以上实例输出结果：

$ python3 test.py 
Hello :  Runoob

一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。

当我们使用import语句的时候，Python解释器是怎样找到对应的文件的呢？
这就涉及到Python的搜索路径，搜索路径是由一系列目录名组成的，Python解释器就依次从这些目录中去寻找所引入的模块。

这看起来很像环境变量，事实上，也可以通过定义环境变量的方式来确定搜索路径。
搜索路径是在Python编译或安装的时候确定的，安装新的库应该也会修改。

-from … import 语句

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：

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

例如，要导入模块 fibo 的 fib 函数，使用如下语句：

from fibo import fib, fib2
fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

这个声明不会把整个fibo模块导入到当前的命名空间中，它只会将fibo里的fib函数引入进来。

-from … import * 语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

from modname import *

这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

-dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回
如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称

-标准模块

Python 本身带着一些标准的模块库，在 Python 库参考文档中将会介绍到（就是后面的"库参考文档"）。

有些模块直接被构建在解析器里，这些虽然不是一些语言内置的功能，但是他却能很高效的使用，甚至是系统级调用也没问题。

这些组件会根据不同的操作系统进行不同形式的配置，比如 winreg 这个模块就只会提供给 Windows 系统。

应该注意到这有一个特别的模块 sys ，它内置在每一个 Python 解析器中。变量 sys.ps1 和 sys.ps2 定义了主提示符和副提示符所对应的字符串

-包

包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。

七、文件File

-open() 方法

Python open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
注意：使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。
open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。

open(file, mode=‘r’)

完整的语法格式为：

open(file, mode=‘r’, buffering=-1, encoding=None, errors=None,
newline=None, closefd=True, opener=None)

参数说明:

file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding:一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener:

mode参数有：在这里插入图片描述
默认为文本模式，如果要以二进制模式打开，加上 b 。

-file 对象

file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：
在这里插入图片描述

八、OS 文件/目录方法

OS 文件/目录方法os 模块提供了非常丰富的方法用来处理文件和目录。常用的方法如下表所示：

序号方法及描述
1os.access(path, mode) 检验权限模式
2os.chdir(path) 改变当前工作目录
3os.chflags(path, flags) 设置路径的标记为数字标记。
4os.chmod(path, mode) 更改权限
5os.chown(path, uid, gid) 更改文件所有者
6os.chroot(path) 改变当前进程的根目录
7os.close(fd) 关闭文件描述符 fd
8os.closerange(fd_low, fd_high) 关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略
9os.dup(fd) 复制文件描述符 fd
10os.dup2(fd, fd2) 将一个文件描述符 fd 复制到另一个 fd2
11os.fchdir(fd) 通过文件描述符改变当前工作目录
12os.fchmod(fd, mode) 改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。
13os.fchown(fd, uid, gid) 修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。
14os.fdatasync(fd) 强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。
15os.fdopen(fd[, mode[, bufsize]]) 通过文件描述符 fd 创建一个文件对象，并返回这个文件对象
16os.fpathconf(fd, name) 返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。
17os.fstat(fd) 返回文件描述符fd的状态，像stat()。
18os.fstatvfs(fd) 返回包含文件描述符fd的文件的文件系统的信息，Python 3.3 相等于 statvfs()。
19os.fsync(fd) 强制将文件描述符为fd的文件写入硬盘。
20os.ftruncate(fd, length) 裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。
21os.getcwd() 返回当前工作目录
22os.getcwdu() 返回一个当前工作目录的Unicode对象
23os.isatty(fd) 如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。
24os.lchflags(path, flags) 设置路径的标记为数字标记，类似 chflags()，但是没有软链接
25os.lchmod(path, mode) 修改连接文件权限
26os.lchown(path, uid, gid) 更改文件所有者，类似 chown，但是不追踪链接。
27os.link(src, dst) 创建硬链接，名为参数 dst，指向参数 src
28os.listdir(path) 返回path指定的文件夹包含的文件或文件夹的名字的列表。
29os.lseek(fd, pos, how) 设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效
30os.lstat(path) 像stat(),但是没有软链接
31os.major(device) 从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。
32os.makedev(major, minor) 以major和minor设备号组成一个原始设备号
33os.makedirs(path[, mode]) 递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。
34os.minor(device) 从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。
35os.mkdir(path[, mode]) 以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。
36os.mkfifo(path[, mode]) 创建命名管道，mode 为数字，默认为 0666 (八进制)
37os.mknod(filename[, mode=0600, device]) 创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。
38os.open(file, flags[, mode]) 打开一个文件，并且设置需要的打开选项，mode参数是可选的
39os.openpty() 打开一个新的伪终端对。返回 pty 和 tty的文件描述符。
40os.pathconf(path, name) 返回相关文件的系统配置信息。
41os.pipe() 创建一个管道. 返回一对文件描述符(r, w) 分别为读和写
42os.popen(command[, mode[, bufsize]])从一个 command 打开一个管道
43os.read(fd, n) 从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
44os.readlink(path) 返回软链接所指向的文件
45os.remove(path) 删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。
46os.removedirs(path) 递归删除目录。
47os.rename(src, dst) 重命名文件或目录，从 src 到 dst
48os.renames(old, new) 递归地对目录进行更名，也可以对文件进行更名。
49os.rmdir(path) 删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
50os.stat(path) 获取path指定的路径的信息，功能等同于C API中的stat()系统调用。
51os.stat_float_times([newvalue]) 决定stat_result是否以float对象显示时间戳
52os.statvfs(path) 获取指定路径的文件系统统计信息
53os.symlink(src, dst) 创建一个软链接
54os.tcgetpgrp(fd) 返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组
55os.tcsetpgrp(fd, pg) 设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。
56os.ttyname(fd) 返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。
57os.unlink(path) 删除文件路径
58os.utime(path, times) 返回指定的path文件的访问和修改的时间。
59os.walk(top[, topdown=True[, οnerrοr=None[, followlinks=False]]]) 输出在文件夹中的文件名通过在树中游走，向上或者向下。
60os.write(fd, str) 写入字符串到文件描述符 fd中. 返回实际写入的字符串长度
61os.path 模块 ---- 获取文件的属性信息。

九、错误和异常

-语法错误

Python 的语法错误或者称之为解析错，是初学者经常碰到的，如下实例

>>>while True print('Hello world')
  File "<stdin>", line 1, in ?
    while True print('Hello world')
                   ^
SyntaxError: invalid syntax

这个例子中，函数 print() 被检查到有错误，是它前面缺少了一个冒号 : 。
语法分析器指出了出错的一行，并且在最先找到的错误的位置标记了一个小小的箭头。

-异常

即便 Python 程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。
大多数的异常都不会被程序处理，都以错误信息的形式展现在这里:

>>>10 * (1/0)             # 0 不能作为除数，触发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ZeroDivisionError: division by zero
>>> 4 + spam*3             # spam 未定义，触发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2               # int 不能与 str 相加，触发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: Can't convert 'int' object to str implicitly

异常以不同的类型出现，这些类型都作为信息的一部分打印出来: 例子中的类型有 ZeroDivisionError，NameError 和 TypeError。
错误信息的前面部分显示了异常发生的上下文，并以调用栈的形式显示具体信息。

-异常处理
1.try/except

异常捕捉可以使用 try/except 语句。
在这里插入图片描述
以下例子中，让用户输入一个合法的整数，但是允许用户中断这个程序（使用 Control-C 或者操作系统提供的方法）。用户中断的信息会引发一个 KeyboardInterrupt 异常。

while True:
    try:
        x = int(input("请输入一个数字: "))
        break
    except ValueError:
        print("您输入的不是数字，请再次尝试输入！")

try语句按照如下方式工作；

  1. 首先，执行 try 子句（在关键字 try 和关键字 except 之间的语句）。
  2. 如果没有异常发生，忽略 except 子句，try 子句执行后结束。
  3. 如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略。 如果异常的类型和 except 之后的名称相符，那么对应的 except 子句将被执行。
  4. 如果一个异常没有与任何的 excep 匹配，那么这个异常将会传递给上层的 try 中。

一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。
处理程序将只针对对应的 try 子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如:

 except (RuntimeError, TypeError, NameError):
    pass

最后一个except子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再次把异常抛出。

import sys
 
try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error: {0}".format(err))
except ValueError:
    print("Could not convert data to an integer.")
except:
    print("Unexpected error:", sys.exc_info()[0])
    raise
2.try/except…else

try/except 语句还有一个可选的 else 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。

else 子句将在 try 子句没有发生任何异常的时候执行。

在这里插入图片描述
以下实例在 try 语句中判断文件是否可以打开，如果打开文件时正常的没有发生异常则执行 else 部分的语句，读取文件内容：

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print('cannot open', arg)
    else:
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到，而 except 又无法捕获的异常。
异常处理并不仅仅处理那些直接发生在 try 子句中的异常，而且还能处理子句中调用的函数（甚至间接调用的函数）里抛出的异常。例如:

>>>def this_fails():
        x = 1/0
   
>>> try:
        this_fails()
    except ZeroDivisionError as err:
        print('Handling run-time error:', err)
   
Handling run-time error: int division or modulo by zero
3.try-finally 语句

try-finally 语句无论是否发生异常都将执行最后的代码。
在这里插入图片描述
以下实例中 finally 语句无论异常是否发生都会执行：

实例 
try:
    runoob()
except AssertionError as error:
    print(error)
    
else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)
        
finally:
    print('这句话，无论异常是否发生都会执行。')
-抛出异常

Python 使用 raise 语句抛出一个指定的异常。
raise语法格式如下：

raise [Exception [, args [, traceback]]]

在这里插入图片描述
以下实例如果 x 大于 5 就触发异常:

x = 10
if x > 5:
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))

执行以上代码会触发异常：

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))
Exception: x 不能大于 5。x 的值为: 10

raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。

>>>try:
        raise NameError('HiThere')
    except NameError:
        print('An exception flew by!')
        raise
   
An exception flew by!
Traceback (most recent call last):
  File "<stdin>", line 2, in ?
NameError: HiThere
-用户自定义异常

你可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承，例如:

>>>class MyError(Exception):
        def __init__(self, value):
            self.value = value
        def __str__(self):
            return repr(self.value)
   
>>> try:
        raise MyError(2*2)
    except MyError as e:
        print('My exception occurred, value:', e.value)
   
My exception occurred, value: 4
>>> raise MyError('oops!')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
__main__.MyError: 'oops!'

在这个例子中，类 Exception 默认的 init() 被覆盖。当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类，然后基于这个基础类为不同的错误情况创建不同的子类:

class Error(Exception):
    """Base class for exceptions in this module."""
    pass
 
class InputError(Error):
    """Exception raised for errors in the input.
 
    Attributes:
        expression -- input expression in which the error occurred
        message -- explanation of the error
    """
 
    def __init__(self, expression, message):
        self.expression = expression
        self.message = message
 
class TransitionError(Error):
    """Raised when an operation attempts a state transition that's not
    allowed.
 
    Attributes:
        previous -- state at beginning of transition
        next -- attempted new state
        message -- explanation of why the specific transition is not allowed
    """
 
    def __init__(self, previous, next, message):
        self.previous = previous
        self.next = next
        self.message = message

大多数的异常的名字都以"Error"结尾，就跟标准的异常命名一样。

-定义清理行为

try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。 例如:

>>>try:
...     raise KeyboardInterrupt
... finally:
...     print('Goodbye, world!')
... 
Goodbye, world!
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
KeyboardInterrupt

以上例子不管try 子句里面有没有发生异常，finally 子句都会执行。如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后被抛出。下面是一个更加复杂的例子（在同一个 try 语句里包含 except 和 finally 子句）:

>>>def divide(x, y):
        try:
            result = x / y
        except ZeroDivisionError:
            print("division by zero!")
        else:
            print("result is", result)
        finally:
            print("executing finally clause")
   
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'
-预定义的清理行为

一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。这面这个例子展示了尝试打开一个文件，然后把内容打印到屏幕上:

for line in open("myfile.txt"):
    print(line, end="")

以上这段代码的问题是，当执行完毕后，文件会保持打开状态，并没有被关闭。关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法:

with open("myfile.txt") as f:
for line in f:
    print(line, end="")

上面这段代码执行完毕后，就算在处理过程中出问题了，文件 f 总是会关闭。

以上内容整理自菜鸟教程及李鹏程老师的课件，如有雷同，不是巧合。

奄奄还有气息
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python中的引用知识点总结
01-20
您可能感兴趣的文章:Python对象与引用的介绍在Python中通过getattr获取对象引用的方法python导入模块交叉引用的方法python引用(import)某个模块提示没找到对应模块的解决方法对python同一个文件夹里面不同.py文件的...
Python123Python语言程序设计2021期末考试题库（选择题）
热门推荐
Richar67的博客
06-30 3万+
下面是eval()函数作用的是：‬‬ A去掉参数中元素两侧所有引号，含单引号或双引号，当作Python语句执行 B直接将参数中元素当作Python语句执行 C去掉参数中做外侧一对引号，含单引号或双引号，当作Python语句执行 D在参数两侧增加一对单引号，当作Python语句执行 正确答案 C ：eval(x)函数用于去掉参数x最外侧一对引号。 下面属于import保留字作用的是： ‬ A改变当前程序的命名空间 B每个程序都必须有这个保留字 C引入程序之外的功能库 D当调用函数时需要使用该保留字 正确答案
Python保留关键字说明
weixin_43661602的博客
12-12 458
保留关键字 说明 and 用于表达式运算，逻辑与操作 as 用于类型转换 assert 断言，用于判断变量或条件表达式的值是否为真 break 中断循环语句的执行 class ...
Python中Import关键字的作用
qq_36372569的博客
02-28 6509
Import … 例 import moudle_name1,moudle_name2 导入一个模块，相当导入的是一个文件夹，使用时 模块.函数 from … import 导入模块中的一个函数，使用时直接使用函数名就可以了 from … import * 导入模块中的所有函数，使用方法同上 from A import B 给A起个外号，方便记忆 import A as B...
2020-11-11
weixin_46519384的博客
11-11 162
while循环 while 条件：当条件成立是循环 循环体 while True： print(“这是一个死循环”) break：退出并结束循环 continue：跳出本次循环，从下一次循环继续执行 元组：如果元组中只有一个元素，一定要在元素后面加一个逗号，否则不认为是元组 menu = (‘红烧鱼’,) #对的 注：元组和列表非常相似，也是有序的线性表，本质上最大的区别就是内容不可变。 字符串：是由数字、字母、下划线组成的一串字符。它是编程语言中表示文本的数据类型，可以用单引号、双引号或三引号来创建字符
Python：T6 Python模块应用(含答案)
WQ的博客
04-23 8996
1. 【单选题】 下列程序不可能输出的结果是D import random x=random.random() print(round(x,2)) A. 0.72 B. 0.15 C. 0.28 D. 1.00 2. 下面程序的可能输出结果是B from random import * print(sample('123456',2)) A. '16' B. ['4','3'] C. [2,5] D.[1,2,3] 3. 【单选题】 下列关于模块的说法错误的是B A.
python全栈知识点总结
01-01
全栈即指的是全栈工程师，指掌握多种技能，并...全栈工程师的厉害之处并不是他掌握很多知识，可以一个人干多份工作。而是说他在处理问题的时候拥有全局性思维。 现在科技日新月异，web前端不再是从前切个图用个jQuery上
python知识点总结.pdf
12-12
python各知识点总结，查阅起来非常方便，对有一定python基础长时间没用或没有python基础但有编程基础的人非常友好，是非常好的总结文档
Python核心知识点总结.doc
05-08
《Python核心知识点总结.doc》是一份非常实用的Python学习资料，适用于初学者和进阶者。本文档总结了Python语言的核心知识点，包括基础语法、数据类型、函数、模块、面向对象编程等内容。通过本文档的学习，读者可以...
python知识点总结
最新发布
03-04
1. 语法基础：Python 的基本语法、变量、数据类型、运算符和控制流等基础知识。 2. 数据结构：Python 中的列表、元组、字典、集合等数据结构的使用和操作。 3. 函数和模块：定义和调用函数，创建和使用模块，以及...
Python期末考试题.pdf
01-08
Python期末考试题
python123 Python语言程序设计 (第11期) 测验1: Python基本语法元素
12-21
第1章测验，共10道单选题和2道编程题，限答1次、限时60分钟，答题后可看答案。 选择题 1.Guido van Rossum正式对外发布Python版本的年份是(B) A. 2008 B. 2002 C. 1998 D. 1991 2.有关python语言中“缩进”的说法正确的是：(A) A.缩进统一为4个空格 B缩进在程序中长度统一且强制使用 C进是非强制的，仅为了提高代码可读性 D缩进可以用在任何语句之后，表示语句间的包含关系 3.以下不属于IPO模型的是：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬
Java 关键字及其作用（保留字）
梦和远方的博客
02-22 1万+
java关键字总览表： 除了上述关键字，Java还有以下保留字：true，false，null Java中的名称命名规范： 包名：多单词组成时所有字母都小写：xxxyyyzzz 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz 常量名：所有字母都大写。多单词时每个单词...
python保留字的基本含义-Python保留字总结
weixin_37988176的博客
11-01 8596
点击上方“数据管道”，选择“置顶星标”公众号干货福利，第一时间送达关键字保留字也称为关键字，指被编程语言内部定义并保留使用的标识符，程序员编写程序时不能定义与保留字相同的标识符。每种程序设计语言都有一套保留字，保留字一般用来构成程序整体框架、表达关键值和具有结构性的复杂语义等。掌握一门编程语言首先要熟记其所对应的保留字。Falseawaitelseimport...
关于Python
m0_68420284的博客
04-30 987
1.关于 Python 的分支结构： A.分支结构使用 if 保留字 B. Python 中 if-else 语句用来形成二分支结构 C. Python 中 if-elif-else 语句描述多分支结构 2.关于 import 引用： A.使用 import turtle 引入turtle 库 B. 使用 import turtle as t 引入 turtle 库，取别名为 t C.import 保留字用于导入模块或者模块中的对象 3.关于 Python 语言的注释： A.Python ...
Python保留字简单释义
python学习者的博客
10-18 1万+
Guido van Rossum在1991年正式对外发布Python版本，现在已成为最流行的语言之一。 分别执行以下命令，查询Python语言中的保留字： import keyword keyword.kwlist 1.False 表示假。 //即在if语句中不会执行。注：在Python中可以给False赋值（改变原有是错误的意思） 2.True 表示真。 //False的反义词 3.No...
python中使用保留字引用当前程序以外的功能库_python入门笔记-turtle库，RGB色彩体系...
weixin_35828992的博客
01-05 472
turtle库是python的标准库之一。turtle绘图体系。绘制窗体：turtle.setup(width,height,startx,starty)turtle 空间坐标体系：绝对坐标：turtle.goto( ,) //让海龟去某一个点海龟坐标：turtle.bk(d) // 海龟的后方运行 turtle.fd(d) // 海龟的正前方运行 turtle.circle(r,angl...
python中importlib模块安装_Python标准模块--importlib
weixin_39952031的博客
11-28 401
作者：zhbzz2007 出处：http://www.cnblogs.com/zhbzz2007 欢迎转载，也请保留这段声明。谢谢！1 模块简介Python提供了importlib包作为标准库的一部分。目的就是提供Python中import语句的实现（以及__import__函数）。另外，importlib允许程序员创建他们自定义的对象，可用于引入过程（也称为importer）。什么是imp？另外...
Python读书笔记-基础篇-3.保留字
lreis2010
10-17 1111
[导读]Python中保留了特定的标识符用来作为关键字在程序中起到一定的逻辑功能，这些保留字是不能作为变量使用的。下面我们一起来品读一下各个保留字的使用。 目录[-] 保留字-and 保留字-or 保留字-import/from...import 保留字-and 在Python中，and执行逻辑运算。但是不同于C/Java，Python中and运算的结果不是布尔值，而是参与运算的值之一。...
Python 知识点总结
03-13
我可以回答这个问题。Python 是一种高级编程语言，常用于数据分析、人工智能、Web 开发等领域。Python 的特点包括简洁、易读、易学、可扩展性强等。Python 的常用库包括 NumPy、Pandas、Matplotlib、Scikit-learn 等。Python 的基础知识包括数据类型、变量、运算符、流程控制语句、函数、模块等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值