当前位置: article > 正文

Python_00000_python将李敏和赵四的信息在创建阶段就加入到列表中。将李艳的信息加入到列表,放

作者：笔触狂放9 | 2024-03-20 09:25:20

踩

python将李敏和赵四的信息在创建阶段就加入到列表中。将李艳的信息加入到列表,放

计算机基础

计算机的使用方式

我们必须要通过软件来对计算机完成各种操作，软件中并不是所有的功能都会对用户开放，用户需要调用软件提供的接口（Interface 交互界面）来操作计算机。

用户界面分成两种：TUI（文本交互界面）和GUI（图形化交互界面）。

Windows的命令行

命令行就是文本交互界面，通过命令行可以使用一个一个的指令来操作计算机。
任何计算机的操作系统中都包含有命令行（windows、linux、macOS）
命令行有多个不同的名字：命令行、命令行窗口、DOS窗口、命令提示符、CMD窗口、Shell、终端、Terminal。

如何进入到命令行？
windows键+R，出现运行窗口，在运行窗口输入cmd，按Enter（回车）键。

命令的语法：命令 [参数] [选项]

常用的dos命令：
dir：查看当前目录下的所有文件（夹）
cd：进入到指定的目录
.：表示当前目录
…：表示上一级目录
md：创建一个目录
rd：删除一个目录
del：删除一个文件
cls：清除屏幕

方向键上下：查看命令的历史记录
Tab键：自动补全

path环境变量

环境变量（environment variable）：指操作系统当中的一些变量。
可以通过修改环境变量，对计算机进行配置（主要是来配置一些路径的）。

path环境变量中保存的是一个一个的路径。
当在命令行中输入一个命令（或访问一个文件时），
系统会首先在当前目录下寻找，如果找到了则直接执行或打开；
如果没有找到，则会依次去path环境变量的路径中去寻找，直到找到为止；
如果path环境变量中的路径都没有找到，则报错：‘xxx’ 不是内部或外部命令，也不是可运行的程序或批处理文件。

可以将一些经常需要访问的文件的路径，添加到path环境变量中，这样就可以在任意位置访问到这些文件了。

1.如果环境变量中没有path，可以手动添加。
2.path环境变量不区分大小写。
3.修改完环境变量必须重新启动命令行窗口。
4.多个路径之间使用;隔开。

练习：

使用DOC命令在桌面创建一个one文件夹，文件中创建一个two.txt文本文件，在给文本文件中输入    任意内容。
然后将one文件夹所在路径添加至path环境变量中，在任意位置访问two.txt。
最后将one文件夹的路径从path环境变量中删除。             
1
2
3
4
5

进制

十进制
满十进一
十进制中一共有10个数字：0、1、2、3、4、5、6、7、8、9
十进制如何计数？ 0 1 2 3 4 5 6 7 8 9 10 11 12 。。。。。。 19 20 。。。。。。29 30

二进制（计算机底层使用的进制）
满二进一
二进制中一共有2个数字: 0 1
二进制如何计数？ 0 1 10 11 100 101 110 111 1000
所有的数据在计算机底层都是以二进制的形式保存的，计算机只认二进制。
可以将内存想象为一个一个的小格子，小格子中可以存储一个0或一个1。内存中的每一个小格子，称为1bit（位）。bit是计算机中的最小的单位。byte是最小的可操作的单位。
8bit = 1byte（字节）
1024byte = 1kb（千字节）
1024kb = 1mb（兆字节）
1024mb = 1gb（吉字节）
1024gb = 1tb（太字节）

八进制
满八进一
八进制中一共有8个数字：0、1、2、3、4、5、6、7
八进制如何计数？0 1 2 3 4 5 6 7 10 11 。。。。。。 17 20 。。。。。。 27 30

十六进制
满十六进一
十六进制中一共有16个数字，由于十六进制是满16才进位，所以十六进制中引入了a、
b、c、d、e、f来分别表示10、11、12、13、14、15 。
0 1 2 3 4 5 6 7 8 9 a b c d e f
十六进制如何计数？
0 1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 。。。。。。 1a 1b 1c 1d 1e 1f
20 21 22 。。。。。。 2a 2b 2c 2d 2e 2f 30
在查看二进制数据时，一般会以十六进制的形式显示。

文本文件和字符集

文本分为两种，一种纯文本，一种做富文本
纯文本中只能保存单一的文本内容，无法保存内容无关的内容（字体、颜色、图片。。。。。。）。
富文本中可以保存文本以外的内容（比如：word文档）。
在开发时，编写程序使用的全都是纯文本。
纯文本在计算机底层也会转换为二进制保存。
编码：将字符转换为二进制码的过程。
解码：将二进制码转换为字符的过程。
编码和解码时所采用的规则，称为字符集。

常见的字符集：
ASCII
美国人编码，使用7位来对美国常用的字符进行编码
包含128个字符。

ISO-8859-1
欧洲的编码，使用8位。
包含256个字符。

GB2312
GBK
国标码，中国的编码。

Unicode
万国码，包含世界上所有的语言和符号，编写程序时一般都会使用Unicode编码。
Unicode编码有多种实现，UTF-8 UTF-16 UTF-32
最常用的就是UTF-8

乱码：编写程序时，如果发现程序代码出现乱码的情况，就要去检查字符集是否正确。

Sublime Text 3

官网地址：http://www.sublimetext.com
可在官网下载Sublime Test安装包。

Sublime Test是纯文本编辑器。

安装Package Control
Package Control：Sublime Text 3中的插件，通过该插件可以向Sublime中安装新的包。
第一步：按Ctrl+Shift+P快捷键。弹出对话框。
第二步：在弹出的对话框中输入install package control。
安装成功后，选择Sublime Test的菜单栏中的“Preferences”，可以看到Package Control。

利用Package Control插件安装Sublime Test的中文语言包。
在Package Control中的文本框中输入：Chinese，选择下拉列表显示的ChineseLocalizations。

基本设置

Python入门

什么是计算机语言

计算机语言发展经历了三个阶段：
机器语言
机器语言通过二进制编码来编写程序
执行效率好，编写起来太麻烦。

符号语言（汇编）
使用符号来代替机器码。
编写程序时，不需要使用二进制，而是直接编写符号。
编写完成后，需要将符号转换为机器码，然后再由计算机执行。
符号转换为机器码的过程称为汇编。
将机器码转换为符号的过程，称为反汇编。
汇编语言一般只适用于某些硬件，兼容性比较差。

高级语言
高级语言的语法基本和现在英语语法类似，并且和硬件的关系没有那么紧密。
也就是说我们通过高级语言开发程序可以在不同的硬件系统中执行。
并且高级语言学习起来也更加的容易，现在我们知道的语言基本都是高级语言。
比如：C、C++、C#、Java、JavaScript、Python 。。。。。。

编译型语言和解释型语言

计算机只能识别二进制编码（机器码），所以任何的语言在交由计算机执行时必须要先转换为机器码，也就是像print(‘hello’)必需要转换为类似1010101这样的机器码。

根据转换时机的不同，语言分成了两大类：

编译型语言
C语言
编译型语言，会在代码执行前将代码编译为机器码，然后将机器码交由计算机执行
a(源码) --编译–> b(编译后的机器码)
特点：1、执行速度特别快2、跨平台性比较差

解释型语言
Python JS Java
解释型语言，不会在执行前对代码进行编译，而是在执行的同时一边执行一边编译。
a（源码）–解释器–> 解释执行
特点：1、执行速度比较慢。2、跨平台性比较好。

Python的介绍

Python是解释型语言。
Python（英国发音：/ˈpaɪθən/ 美国发音：/ˈpaɪθɑːn/），是一种广泛使用的高级编程语言，属于通用型编程语言，由吉多·范罗苏姆创造，第一版发布于1991年。可以视之为一种改良（加入一些其他编程语言的优点，如面向对象）的LISP。作为一种解释型语言，Python的设计哲学强调代码的可读性和简洁的语法（尤其是使用空格缩进划分代码块，而非使用大括号或者关键词）。相比于C++或Java，Python让开发者能够用更少的代码表达想法。不管是小型还是大型程序，该语言都试图让程序的结构清晰明了。

Python的用途：
WEB应用
Facebook 豆瓣。。。
爬虫程序
科学计算
自动化运维
大数据（数据清洗）
云计算
桌面软件/游戏
人工智能
。。。。。。

Python开发环境搭建

开发环境搭建：安装Python的解释器。

Python的解释器分类：
CPython（官方）：用c语言编写的Python解释器
PyPy：用Python语言编写的Python解释器
IronPython：用.net编写的Python解释器
Jython：用Java编写的Python解释器

步骤：
1.官网下载安装包
官网地址：https://www.python.org
2.安装
3.打开命令行窗口，输入python进行验证安装是否成功。如果输出如下内容，则安装成功。
Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 16:07:46) [MSC v.1900 32 bit (Intel)] on win32
Type “help”, “copyright”, “credits” or “license” for more information.

Python的交互界面

当通过命令行来输入Python，所进入到的界面就是Python的交互界面。
结构：
版本和版权声明：
Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 16:07:46) [MSC v.1900 32 bit (Intel)] on win32
Type “help”, “copyright”, “credits” or “license” for more information.

命令提示符：>>>

在命令提示符后可以直接输入Python的指令！输入完的指令将会被Python的解释器立即执行。

安装Python的同时，会自动安装一个Python的开发工具IDLE，通过IDLE也可以进入到交互模式，但是不同的是，在IDLE中可以通过TAB键来查看语句的提示。
IDLE实际上就是一个交互界面，但是他可以有一些简单的提示，并且可以将代码保存。

交互模式只能你输入一行代码，它就是执行一行，所以他并不适用于我们日常的开发。仅可以用来做一些日常的简单的测试！
一般会将Python代码编写到一个py文件中，然后通过python指令来执行文件中的代码。

Python与Sublime的整合

1.在Sublime中执行Python代码，ctrl+b快捷键自动在Sublime内置的控制台中执行。这种执行方式，在某些版本的Sublime中对中文支持不好，并且不能使用input()函数。
2.使用SublimeREPL来运行python代码。
安装完成，设置快捷键，希望按f5自动执行当前的Python代码：

{

    “keys”: [“f5”],
    “caption”: “SublimeREPL:Python”,
    “command”: “run_existing_window_command”,

    “args”:{

        “id”: “repl_python_run”,
        “file”: “config/Python/Main.sublime-menu”

    }

},

几个概念

1.表达式
表达式类似于数学公式比如：10 + 5、8 - 4。
表达式一般仅仅计算一些结果，不会对程序产生实质性的影响。
如果在交互模式中输入一个表达式，解释器会自动将表达式的结果输出。

2.语句
在程序中语句一般需要完成某种功能，比如打印信息、获取信息、为变量赋值。。。。。。
比如：print()、input()、a = 10。
语句的执行一般会对程序产生一定的影响。
在交互模式中不一定会输出语句的执行结果

3.程序（program）
程序就是由一条一条的语句和一条一条的表达式构成的。

4.函数（function）
函数就是一种语句，函数专门用来完成特定的功能。

函数的分类：
内置函数：由Python解释器提供的函数，可以在Python中直接使用。
自定义函数：由程序员自主创建的函数。

当我们需要完成某个功能时，就可以去调用内置函数，或者自定义函数。

函数的两个要素：
1、参数
()中的内容就是函数的参数
函数中可以没有参数，也可以有多个参数，多个参数之间使用,隔开。
2、返回值
返回值是函数的返回结果，不是所有的函数都有返回值。

基本语法

1.在Python中严格区分大小写。
2.Python中的每一行就是一条语句，每条语句以换行结束。
3.Python中每一行语句不要过长（规范中建议每行不要超过80个字符）。
“rulers”:[80],
4.一条语句可以分多行编写，多行编写时语句后边以\结尾。
5.Python是缩进严格的语言，所以在Python中不要随便写缩进。
6.在Python中使用#来表示注释，#后的内容都属于注释，注释的内容将会被解释器所忽略。

print('hello,你好。')
print(1 + 2)
print('1','2')
print('1 2')
print('12')
print('hello', '宋江', 'one')
1
2
3
4
5
6

print('aa\
bbb\
cccc') #这是注释
1
2
3

字面量和变量

字面量就是一个一个的值。比如：1，2，3，4，5，6，‘HELLO’。
字面量所表示的意思就是它的字面的值，在程序中可以直接使用字面量。

变量（variable）可以用来保存字面量，并且变量中保存的字面量是不定的，变量本身没有任何意思，它会根据不同的字面量表示不同的意思。

一般在开发中，很少直接使用字面量，都是将字面量保存到变量中，通过变量来引用字面量。

变量和标识符

标识符
在Python中所有可以自主命名的内容都属于标识符。
比如：变量名、函数名、类名。

标识符必须遵循标识符的规范：
1.标识符中可以含有字母、数字、_，但是不能以数字开头
例子：a_1 _a1 _1a
2.标识符不能是Python中的关键字和保留字。
也不建议使用Python中的函数名作为标识符,因为这样会导致函数被覆盖。
3.命名规范：
在Python中注意遵循两种命名规范：
下划线命名法：所有字母小写，单词之间使用_分割。如：max_length、min_length、hello_world、xxx_yyy_zzz
帕斯卡命名法（大驼峰命名法）：首字母大写，每个单词开头字母大写，其余字母小写。如：MaxLength、MinLength、HelloWorld、XxxYyyZzz

如果使用不符合标准的标识符，将会报错：SyntaxError: invalid syntax

a = 20
print(a)
1
2

# Python中使用变量，不需要声明，直接为变量赋值即可。
a = 10

# 不能使用没有进行过赋值的变量
# 如果使用没有赋值过的变量，会报错 NameError: name 'b' is not defined
# print(b)

# Python是一个动态类型的语言，可以为变量赋任意类型的值，也可以任意修改变量的值
a = 'hello'

# print(a)
_b123 = 20
# print(_b123)

# print = 123
# print(print)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

数据类型

数据类型指的就是变量的值的类型，也就是可以为变量赋哪些值。

数值
    整型
        布尔值
    浮点型
    复数
    
字符串

空值
1
2
3
4
5
6
7
8
9
10
11

# 在Python数值分成了三种：整数、浮点数（小数）、复数
# 在Python中所有的整数都是int类型
a = 10
b = 20
# Python中的整数的大小没有限制，可以是一个无限大的整数
# c = 999999999999999999999999999999999999999999999 ** 100

# 如果数字的长度过大，可以使用下划线作为分隔符
c = 123_456_789

# d = 0123 10进制的数字不能以0开头
# 其他进制的整数，只要是数字打印时一定是以十进制的形式显示的
# 二进制 0b开头
c = 0b10 # 二进制的10
# 八进制 0o开头
c = 0o10
# 十六进制 0x开头
c = 0x10

# 也可以通过运算符来对数字进行运算，并且可以保证整数运算的精确
c = -100
c = c + 3

# 浮点数（小数），在Python中所有的小数都是float类型
c = 1.23
c = 4.56

# 对浮点数进行运算时，可能会得到一个不精确的结果
c = 0.1 + 0.2 # 0.30000000000000004

print(c)
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

# 字符串(str)
# 字符串用来表示一段文本信息，字符串是程序中使用的最多的数据类型
# 在Python中字符串需要使用引号引起来

s = 'hello'
# s = abc # 字符串必须使用引号引起来，不使用不是字符串
# 引号可以是双引号，也可以是单引号，但是注意不要混着用
s = 'hello'
s = "hello"
# s = 'hello" 引号不能混合使用  SyntaxError: EOL while scanning string literal

# 相同的引号之间不能嵌套
# s = "子曰:"学而时习之，乐呵乐呵！""
s = '子曰:"学而时习之，乐呵乐呵！"'

# 长字符串
# 单引号和双引号不能跨行使用
s = '锄禾日当午，\
汗滴禾下土，\
谁知盘中餐，\
粒粒皆辛苦'

# 使用三重引号来表示一个长字符串 ''' """
# 三重引号可以换行，并且会保留字符串中的格式

s = '''锄禾日当午，
汗滴禾下土，
谁知盘中餐，
粒粒皆辛苦'''

# 转义字符
# 可以使用 \ 作为转义字符，通过转义字符，可以在字符串中使用一些特殊的内容
# 例子：
#   \' 表示'
#   \" 表示"
#   \t 表示制表符
#   \n 表示换行符
#   \\ 表示反斜杠
#   \uxxxx 表示Unicode编码
s = "子曰:\"学而时习之，\\\\n乐呵乐呵！\""

s = '\u2250'
print(s)
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
35
36
37
38
39
40
41
42
43

# 格式化字符串
a = 'hello'

# 字符串之间也可以进行加法运算
# 如果将两个字符串进行相加，则会自动将两个字符串拼接为一个
a = 'abc' + 'haha' + '哈哈'
# a = 123 
# 字符串只能不能和其他的类型进行加法运算，如果做了会出现异常 TypeError: must be str, not int
# print("a = "+a) # 这种写法在Python中不常见
a = 123
# print('a =',a)

# 在创建字符串时，可以在字符串中指定占位符
# %s 在字符串中表示任意字符
# %f 浮点数占位符
# %d 整数占位符
b = 'Hello %s'%'孙悟空'
b = 'hello %s 你好 %s'%('tom','孙悟空')
b = 'hello %3.5s'%'abcdefg' # %3.5s字符串的长度限制在3-5之间
b = 'hello %s'%123.456
b = 'hello %.2f'%123.456
b = 'hello %d'%123.95
b = '呵呵'

# print('a = %s'%a)

# 格式化字符串，可以通过在字符串前添加一个f来创建一个格式化字符串
# 在格式化字符串中可以直接嵌入变量
c = f'hello {a} {b}'

print(f'a = {a}')

# 练习 创建一个变量保存你的名字，然后通过四种格式化字符串的方式
#   在命令行中显示，欢迎 xxx 光临！
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

# 创建一个变量来保存你的名字
name = '孙悟空'

# 使用四种方式来输出，欢迎 xxx 光临
# 拼串
print('欢迎 '+name+' 光临！')
# 多个参数
print('欢迎',name,'光临！')
# 占位符
print('欢迎 %s 光临！'%name)
# 格式化字符串
print(f'欢迎 {name} 光临！')

# 字符串的复制（将字符串和数字相乘）
a = 'abc'
# * 在语言中表示乘法
# 如果将字符串和数字相乘，则解释器会将字符串重复指定的次数并返回
a = a * 20

print(a)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 布尔值（bool）
# 布尔值主要用来做逻辑判断
# 布尔值一共有两个 True 和 False
# True表示真 False表示假
a = True
a = False
# print('a =',a)

# 布尔值实际上也属于整型，True就相当于1，False就相当于0
# print(1 + False)

# None（空值）
# None专门用来表示不存在
b = None
print(b)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

类型检查

# 通过类型检查，可以检查只能值（变量）的类型

a = 123 # 数值
b = '123' # 字符串

# print('a =',a)
# print('b =',b)、

# type()用来检查值的类型
# 该函数会将检查的结果作为返回值返回，可以通过变量来接收函数的返回值
c = type('123')
c = type(a)
# print(type(b))
print(type(1)) # <class 'int'>
print(type(1.5)) # <class 'float'>
print(type(True)) # <class 'bool'>
print(type('hello'))  # <class 'str'>
print(type(None)) # <class 'NoneType'>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

对象（object）

- Python是一门面向对象的语言
- 一切皆对象！
- 程序运行当中，所有的数据都是存储到内存当中然后再运行的！
- 对象就是内存中专门用来存储指定数据的一块区域
- 对象实际上就是一个容器，专门用来存储数据
- 像我们之前学习的数值、字符串、布尔值、None都是对象
- 参考 图1
1
2
3
4
5
6
7

对象的结构

- 每个对象中都要保存三种数据
    - id（标识）
        > id用来标识对象的唯一性，每一个对象都有唯一的id
        > 对象的id就相当于人的身份证号一样
        > 可以通过id()函数来查看对象的id
        > id是由解析器生成的，在CPython中，id就是对象的内存地址
        > 对象一旦创建，则它的id永远不能再改变

    - type（类型）
        > 类型用来标识当前对象所属的类型
        > 比如：int str float bool 。。。
        > 类型决定了对象有哪些功能
        > 通过type()函数来查看对象的类型
        > Python是一门强类型的语言，对象一旦创建类型便不能修改


    - value（值）
        > 值就是对象中存储的具体的数据
        > 对于有些对象值是可以改变的
        > 对象分成两大类，可变对象 不可变对象
            可变对象的值可以改变
            不可变对象的值不能改变，之前学习的对象都是不可变对象
    - 参考 图2

练习：尝试自己画一下对象的内存结构。  
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

变量和对象

- 对象并没有直接存储到变量中，在Python中变量更像是给对象起了一个别名
- 变量中存储的不是对象的值，而是对象的id（内存地址），
    当我们使用变量时，实际上就是在通过对象id在查找对象
- 变量中保存的对象，只有在为变量重新赋值时才会改变
- 变量和变量之间是相互独立的，修改一个变量不会影响另一个变量

- 参考 图3
1
2
3
4
5
6
7

类型转换

- 所谓的类型转换，将一个类型的对象转换为其他对象
- 类型转换不是改变对象本身的类型，而是根据当前对象的值创建一个新对象
1
2

# 类型转换四个函数 int() float() str() bool()
# int() 可以用来将其他的对象转换为整型
# 规则：
#   布尔值：True -> 1   False -> 0
#   浮点数：直接取整，省略小数点后的内容
#   字符串：合法的整数字符串，直接转换为对应的数字
#           如果不是一个合法的整数字符串，则报错 ValueError: invalid literal for int() with base 10: '11.5'
#   对于其他不可转换为整型的对象，直接抛出异常 ValueError
# float() 和 int()基本一致，不同的是它会将对象转换为浮点数
# str() 可以将对象转换为字符串
#  True -> 'True'
#  False -> 'False'
#  123 -> '123' 
#  。。。
#  bool() 可以将对象转换为布尔值，任何对象都可以转换为布尔值
#   规则：对于所有表示空性的对象都会转换为False，其余的转换为True
#       哪些表示的空性：0 、 None 、 '' 。。。

a = True

# 调用int()来将a转换为整型
# int()函数不会对原来的变量产生影响，他是对象转换为指定的类型并将其作为返回值返回
# 如果希望修改原来的变量，则需要对变量进行重新赋值
a = int(a)

a = False
a = int(a)

a = '123'
a = int(a)

a = 11.6
a = int(a)

a = '11.5'
# a = int(a)

a = None
# a = int(a)

a = 1
a = float(a)

a = False
a = float(a)

a = 123
a = str(a)

a = None
a = bool(a)

print('a =',a)
print('a的类型是',type(a))
# b = 456
# print('hello'+str(b))
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

运算符(操作符)

- 运算符可以对一个值或多个值进行运算或各种操作
- 比如 + 、-、= 都属于运算符
- 运算符的分类：
    1.算术运算符
    2.赋值运算符
    3.比较运算符（关系运算符）
    4.逻辑运算符
    5.条件运算符（三元运算符）    
1
2
3
4
5
6
7
8

# 算术运算符
# + 加法运算符（如果是两个字符串之间进行加法运算，则会进行拼串操作）
# - 减法运算符
# * 乘法运算符（如果将字符串和数字相乘，则会对字符串进行复制操作，将字符串重复指定次数）
# / 除法运算符，运算时结果总会返回一个浮点类型
# // 整除，只会保留计算后的整数位，总会返回一个整型
# ** 幂运算，求一个值的几次幂
# % 取模，求两个数相除的余数

a = 10 + 5 # 计算
a = 'hello' + ' ' + 'world' # 拼串

a = 10 - 5 # 计算
a = 5 - True 
a = a - 2 # 用变量a的值减去2，然后再赋值给a
# a = 'hello' - 'h' TypeError

a = 5 * 5

a = 10 / 5
a = 5 / 2
# a = 5 / 0 ZeroDivisionError: division by zero
a = 10 / 3
a = 10 // 3
a = 5 // 2 

a = 2 ** 2
a = 10 ** 5
a = 16 ** 0.5 # 求16的平方根

a = 10 % 5 # 0
a = 10 % 4 # 2
a = 10 % 3 # 1
a = 10 % 2 # 0

print("a =",a)
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
35
36

流程控制语句

简介

Python代码在执行时是按照自上向下顺序执行的。
通过流程控制语句，可以改变程序的执行顺序，也可以让指定的程序反复执行多次
流程控制语句分成两大类：条件判断语句，循环语句
1
2
3

条件判断语句（if语句）

练习1：
    编写一个程序，获取一个用户输入的整数。然后通过程序显示这个数是奇数还是偶数。

练习2：
    编写一个程序，检查任意一个年份是否是闰年。
    如果一个年份可以被4整除不能被100整除，或者可以被400整除，这个年份就是闰年

练习3：
    我家的狗5岁了，5岁的狗相当于多大年龄的人呢？
    其实非常简单，狗的前两年每一年相当于人类的10.5岁，然后每增加一年就增加四岁。
    那么5岁的狗相等于人类的年龄就应该是10.5+10.5+4+4+4 = 33岁 

    编写一个程序，获取用户输入的狗的年龄，然后通过程序显示其相当于人类的年龄。
    如果用户输入负数，请显示一个提示信息

练习4：
    从键盘输入小明的期末成绩:
        当成绩为100时，'奖励一辆BMW'
        当成绩为[80-99]时，'奖励一台iphone'
        当成绩为[60-79]时，'奖励一本参考书'
        其他时，什么奖励也没有

练习5：
    大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件：
        高：180cm以上; 富:1000万以上; 帅:500以上;
        如果这三个条件同时满足，则:'我一定要嫁给他'
        如果三个条件有为真的情况，则:'嫁吧，比上不足，比下有余。'
        如果三个条件都不满足，则:'不嫁！'
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

# 条件判断语句（if语句）
# 语法：if 条件表达式 : 
#           代码块
# 执行的流程：if语句在执行时，会先对条件表达式进行求值判断，
#   如果为True，则执行if后的语句
#   如果为False，则不执行
# 默认情况下，if语句只会控制紧随其后的那条语句，如果希望if可以控制多条语句，
#   则可以在if后跟着一个代码块
# 代码块
#   代码块中保存着一组代码，同一个代码块中的代码，要么都执行要么都不执行
#   代码块就是一种为代码分组的机制
#   如果要编写代码块，语句就不能紧随在:后边，而是要写在下一行
#   代码块以缩进开始，直到代码恢复到之前的缩进级别时结束
#   鲁迅说过：
#       世上本来没有路，走的人多了自然就有了！
#       xxxx
#   yyyy....
# 缩进有两种方式，一种是使用tab键，一种是使用空格（四个）
#   Python的官方文档中推荐我们使用空格来缩进
#   Python代码中使用的缩进方式必须统一
#   "translate_tabs_to_spaces": true,     

# if False : print('你猜我出来么？')

num = 10
# if num > 10 : print('num比10大！')
# print('谁也管不了我')

if False :
    print(123)
    print(456)
    print(789)
    print(101112)
# print('hello')

num = 28

# 可以使用逻辑运算符来连接多个条件，
#   如果希望所有条件同时满足，则需要使用and
#   如果希望只要有一个条件满足即可，则需要使用or
# if num > 10 and num < 20 :
#     print('num比10大,num比20小！')

# if 10 < num < 20 :
#     print('num比10大,num比20小！')

# 在命令行让用户输入一个用户名，获取用户输入，并进行判断
# 如果用户输入的用户名是admin，则显示欢迎管理员光临
# 如果用户输入的是其他的用户名，则什么也不做
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

# input()函数
# 该函数用来获取用户的输入
# input()调用后，程序会立即暂停，等待用户输入
#   用户输入完内容以后，点击回车程序才会继续向下执行
#   用户输入完成以后，其所输入的的内容会以返回值得形式返回
#   注意：input()的返回值是一个字符串
#   input()函数中可以设置一个字符串作为参数，这个字符串将会作为提示文字显示
# a = input('请输入任意内容：')
# print('用户输入的内容是:',a)
# input()也可以用于暂时阻止程序结束

# 获取用户输入的用户名
username = input('请输入你的用户名:')
# 判断用户名是否是admin
if username == 'admin' :
    print('欢迎管理员光临！')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 让用户在控制台中输入一个年龄
# age = int(input('请输入你的年龄：'))

# 如果用户的年龄大于18岁，则显示你已经成年了
# if age >= 18 :
#     print('你已经成年了~~~')

# if-else语句
# 语法： 
#   if 条件表达式 :
#       代码块
#   else :
#       代码块
# 执行流程：
#   if-else语句在执行时，先对if后的条件表达式进行求值判断
#       如果为True，则执行if后的代码块
#       如果为False，则执行else后的代码块

age = 7
if age > 17 :
    print('你已经成年了~~')
else :
    print('你还未成年~~')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# if-elif-else语句
# 语法：
#   if 条件表达式 :
#       代码块
#   elif 条件表达式 :
#       代码块
#   elif 条件表达式 :
#       代码块
#   elif 条件表达式 :
#       代码块
#   else :
#       代码块
#       
# 执行流程：
#   if-elif-else语句在执行时，会自上向下依次对条件表达式进行求值判断，
#       如果表达式的结果为True，则执行当前代码块，然后语句结束
#       如果表达式的结果为False，则继续向下判断，直到找到True为止
#       如果所有的表达式都是False，则执行else后的代码块
#   if-elif-else中只会有一个代码块会执行

age = 210

# if age > 200 :
#     print('活着可真没劲呢！')
# elif age > 100 :
#     print('你也是老大不小了！')
# elif age >= 60 :
#     print('你已经退休了！')
# elif age >= 30 :
#     print('你已经是中年了！')
# elif age >= 18 :
#     print('你已经成年了！')
# else :
#     print('你还是个小孩！')

age = 68

if age >= 18 and age < 30 :
    print('你已经成年了！')
elif age >= 30 and age < 60 :
    print('你已经中年了！')
elif age >= 60 :
    print('你已经退休了！')
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
35
36
37
38
39
40
41
42
43

# 练习1：
#     编写一个程序，获取一个用户输入的整数。然后通过程序显示这个数是奇数还是偶数。
# 获取用户输入的整数
# num = int(input('请输入一个任意的整数：'))

# # 显示num是奇数还是偶数
# if num % 2 == 0 :
#     print(num , "是偶数")
# else :
#     print(num , '是奇数')


# 练习2：
#     编写一个程序，检查任意一个年份是否是闰年。
#     如果一个年份可以被4整除不能被100整除，或者可以被400整除，这个年份就是闰年
# year = int(input('请输入一个任意的年份:'))
# # 检查这个年份是否是闰年
# # year % 4 == 0 and year % 100 != 0 or year % 400 == 0
# if year % 4 == 0 and year % 100 != 0 or year % 400 == 0 :
#     print(year,'是闰年')
# else :
#     print(year,'是平年')

# 练习3：
#     我家的狗5岁了，5岁的狗相当于多大年龄的人呢？
#     其实非常简单，狗的前两年每一年相当于人类的10.5岁，然后每增加一年就增加四岁。
#     那么5岁的狗相等于人类的年龄就应该是10.5+10.5+4+4+4 = 33岁 

#     编写一个程序，获取用户输入的狗的年龄，然后通过程序显示其相当于人类的年龄。
#     如果用户输入负数，请显示一个提示信息

# dog_age = float(input('请输入狗的年龄：'))
# like_person_age = 0
# 检查用户输入的是否是负数
# if dog_age < 0 :
#     print('你的输入不合法！')
# # 如果狗的年龄在两岁以下（包含两岁）
# elif dog_age <= 2 :
#     # 直接将当前的年龄乘以10.5
#     like_person_age = dog_age * 10.5
# # 如果狗的年龄在两岁以上
# else :
#     # 计算前两岁相当于人类的年纪
#     like_person_age = 2 * 10.5
#     # 计算超过两岁的部分相对于人类的年纪，并进行相加
#     like_person_age += ( dog_age - 2 ) * 4

# if dog_age > 0 :
#     print(dog_age,'岁的狗，年纪相当于',like_person_age,'岁的人')
#     

# 在if也可以去嵌套if，代码块是可以嵌套的，每增加一个缩进的级别，代码块就低一级
# 检查用户的输入是否合法
# if dog_age > 0 :
#     # 如果狗的年龄在两岁以下（包含两岁）
#     if dog_age <= 2 :
#         # 直接将当前的年龄乘以10.5
#         like_person_age = dog_age * 10.5
#     # 如果狗的年龄在两岁以上
#     else :
#         # 计算前两岁相当于人类的年纪
#         like_person_age = 2 * 10.5
#         # 计算超过两岁的部分相对于人类的年纪，并进行相加
#         like_person_age += ( dog_age - 2 ) * 4

#     print(dog_age,'岁的狗，年纪相当于',like_person_age,'岁的人')
# else :
#     print('请输入一个合法的年龄！')


# 练习4：
#     从键盘输入小明的期末成绩:
#         当成绩为100时，'奖励一辆BMW'
#         当成绩为[80-99]时，'奖励一台iphone'
#         当成绩为[60-79]时，'奖励一本参考书'
#         其他时，什么奖励也没有

# 获取小明的成绩
# score = float(input('请输入你的期末成绩(0-100)：'))

# # 打印分割线
# print("="*40)

# # 检查用户的输入是否合法
# if 0 <= score <= 100 :
#     # 判断发给的奖励
#     if score == 100 :
#         print('宝马，拿去玩！')
#     elif score >= 80 :
#         print('苹果手机，拿去玩！')
#     elif score >= 60 :
#         print('参考书，拿去玩！')
#     else :
#         print('棍子一根！')
# else :
#     # 用户输入的不合法，弹出一个友好提示
#     print('你输入的内容不合法，拉出去毙了！')


# 练习5：
#     大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件：
#         高：180cm以上; 富:1000万以上; 帅:500以上;
#         如果这三个条件同时满足，则:'我一定要嫁给他'
#         如果三个条件有为真的情况，则:'嫁吧，比上不足，比下有余。'
#         如果三个条件都不满足，则:'不嫁！'

# 获取用户的三个数据，身高、财富、颜值
height = float(input('请输入你的身高(厘米):'))
money = float(input('请输入你的财富(万):'))
face = float(input('请输入你的颜值(平方厘米):'))

# 判断到底嫁不嫁
# 如果这三个条件同时满足，则:'我一定要嫁给他'
if height > 180 and money > 1000 and face > 500 :
    print('我一定要嫁给他！')
# 如果三个条件有为真的情况，则:'嫁吧，比上不足，比下有余。'
elif height > 180 or money > 1000 or face > 500 :
    print('嫁吧，比上不足，比下有余。')
# 如果三个条件都不满足，则:'不嫁！'
else :
    print('不嫁！')
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

循环语句

练习1：
    求100以内所有的奇数之和

练习2：
    求100以内所有7的倍数之和，以及个数

练习3： 
    水仙花数是指一个 n 位数（n≥3 ），它的每个位上的数字的 n 次幂之和等于它本身（例如：1**3 + 5**3 + 3**3 = 153）。
    求1000以内所有的水仙花数

练习4：    
    获取用户输入的任意数，判断其是否是质数。质数是只能被1和它自身整除的数，1不是质数也不是合数。
1
2
3
4
5
6
7
8
9
10
11
12

# 循环语句
# 循环语句可以使指定的代码块重复指定的次数
# 循环语句分成两种，while循环 和 for循环
# while循环
# 语法：
#   while 条件表达式 :
#       代码块
#   else :
#       代码块
# 执行流程：
#   while语句在执行时，会先对while后的条件表达式进行求值判断，
#       如果判断结果为True，则执行循环体（代码块），
#       循环体执行完毕，继续对条件表达式进行求值判断，以此类推，
#       直到判断结果为False，则循环终止，如果循环有对应的else，则执行else后的代码块

# 条件表达式恒为True的循环语句，称为死循环，它会一直运行，慎用！
# while True :
#     print('hello')

# 循环的三个要件（表达式）
# 初始化表达式，通过初始化表达式初始化一个变量
# i = 0

# # 条件表达式，条件表达式用来设置循环执行的条件
# while i < 10 :
#     print(i)
#     # 更新表达式，修改初始化变量的值
#     i += 1

# 创建一个执行十次的循环
i = 0
while i < 10 :
    i += 1
    print(i,'hello')
else :
    print('else中的代码块')
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
35
36

# 求100以内所有的奇数之和
# 获取所有100以内数
# i = 0
# # 创建一个变量，用来保存结果
# result = 0
# while i < 100 :
#     i += 1
#     # 判断i是否是奇数
#     if i % 2 != 0:
#         result += i

# print('result =',result)

# 获取100以内所有的奇数
# i = 1
# while i < 100:
#     print(i)
#     i += 2

# 求100以内所有7的倍数之和，以及个数
i = 7 
# 创建一个变量，来保存结果
result = 0
# 创建一个计数器，用来记录循环执行的次数
# 计数器就是一个变量，专门用来记录次数的变量
count = 0
while i < 100:
    # 为计数器加1
    count += 1
    result += i
    i += 7    

print('总和为：',result,'总数量为:',count)
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

# 水仙花数是指一个 n 位数（n≥3 ），它的每个位上的数字的 n 次幂之和等于它本身（例如：1**3 + 5**3 + 3**3 = 153）。
# 求1000以内所有的水仙花数

# 获取1000以内的三位数
i = 100
while i < 1000:

    # 假设，i的百位数是a，十位数b，个位数c
    # 求i的百位数
    a = i // 100
    # 求i的十位数
    # b = i // 10 % 10
    b = (i - a * 100) // 10
    # 求i的个位数字
    c = i % 10
    # print(i , a , b , c)
    
    # 判断i是否是水仙花数
    if a**3 + b**3 + c**3 == i :
        print(i)
    i += 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

循环嵌套

练习1：
    打印99乘法表
    1*1=1
    1*2=2 2*2=4
    1*3=3 2*3=6 3*3=9
    ...                 9*9=81

练习2：
    求100以内所有的质数
1
2
3
4
5
6
7
8
9

# 获取用户输入的任意数，判断其是否是质数。
num = int(input('输入一个任意的大于1的整数：'))

# 判断num是否是质数，只能被1和它自身整除的数就是质数
# 获取到所有的可能整除num的整数
i = 2
# 创建一个变量，用来记录num是否是质数，默认认为num是质数
flag = True
while i < num:
    # 判断num能否被i整除
    # 如果num能被i整除，则说明num一定不是质数
    if num % i == 0 :
        # 一旦进入判断，则证明num不是质数，则需要将flag修改为false
        flag = False
    i += 1

if flag :
    print(num,'是质数')
else :
    print(num,'不是质数')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 在控制台中打印如下图形
# *****
# *****
# *****
# *****
# *****

# 创建一个循环来控制图形的高度
# 循环嵌套时，外层循环每执行一次，内层循环就要执行一圈
# i = 0
# while i < 5:
#     # 创建一个内层循环来控制图形的宽度
#     j = 0
#     while j < 5:
#         print("* ",end='')
#         j += 1
#     print()
#     i += 1

#
# *     j<1   i=0
# **    j<2   i=1   
# ***   j<3   i=2
# ****  j<4   i=3
# ***** j<5   i=4
# 
# *****
# ****
# ***
# **
# *
i = 0
while i < 5:
    j = 0
    while j < i + 1:
        print("* ",end='')
        j += 1
    print()
    i += 1


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
35
36
37
38
39
40
41

# 练习1：
#   打印99乘法表
#   1*1=1
#   1*2=2 2*2=4
#   1*3=3 2*3=6 3*3=9
#   ...                 9*9=81

# 创建一个外层循环来控制图形的高度
i = 0
while i < 9:
    i += 1
    
    # 创建一个内层循环来控制图形的宽度
    j = 0
    while j < i:
        j += 1
        print(f"{j}*{i}={i*j} ",end="")

    print()


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 求100以内所有的质数
# 创建一个循环，求1-100以内所有的数
i = 2
while i <= 100:
    
    # 创建一个变量，记录i的状态，默认认为i是质数
    flag = True

    # 判断i是否是质数
    # 获取所有可能成为i的因数的数
    j = 2 
    while j < i:
        # 判断i能否被j整除
        if i % j == 0:
            # i能被j整除，证明i不是质数，修改flag为False
            flag = False
        j += 1
    # 验证结果并输出
    if flag :
        print(i)   

    i += 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

break和continue

# break
# break可以用来立即退出循环语句（包括else）
# continue
# continue可以用来跳过当次循环
# break和continue都是只对离他最近的循环起作用
# pass
# pass是用来在判断或循环语句中占位的

# 创建一个5次的循环
# i = 0
# while i < 5:
#     if i == 3:
#         break
#     print(i)
#     i += 1
# else :
#     print('循环结束')

# i = 0
# while i < 5:
#     i += 1
#     if i == 2:
#         continue
#     print(i)
# else :
#     print('循环结束')

i = 0
if i < 5:
    pass
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

# 模块，通过模块可以对Python进行扩展
# 引入一个time模块，来统计程序执行的时间
from time import *
# time()函数可以用来获取当前的时间，返回的单位是秒
# 获取程序开始的时间
# 优化前：
#   10000个数 12.298秒
#   100000个数 没有结果
# 第一次优化
#   10000个数 1.577秒
#   100000个数 170.645秒
# 第二次优化
#   10000个数 0.068秒
#   100000个数 1.646秒
#
# 36的因数
#   2 18
#   3 12
#   4 9
#   6 6
#   
begin = time()

i = 2
while i <= 100000:
    flag = True
    j = 2 
    while j <= i ** 0.5:
        if i % j == 0:
            flag = False
            # 一旦进入判断，则证明i一定不是质数，此时内层循环没有继续执行的必要
            # 使用break来退出内层的循环
            break
        j += 1
    if flag :
        # print(i)  
        pass
    i += 1

# 获取程序结束的时间
end = time()

# 计算程序执行的时间
print("程序执行花费了：",end - begin , "秒")
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
35
36
37
38
39
40
41
42
43
44

小游戏《唐僧大战白骨精》

1、身份选择
    ① 显示提示信息
        欢迎光临 xxx 游戏！
        请选择你的身份：
            1.xxx
            2.xxx
        请选择：x
    ② 根据用户选择来分配身份（显示不同的提示消息）  
        1.---
        2.---
        3.---  

2、游戏进行
    ① 显示玩家的基本信息（攻击力 生命值）
    ② 显示玩家可以进行的操作：
        1、练级
            - 提升玩家的攻击力和生命值
        2、打BOSS
            - 玩家对BOSS进行攻击，玩家要攻击BOSS，BOSS对玩家进行反击
            - 计算BOSS是否被玩家消灭，玩家是否被BOSS消灭
            - 游戏结束
        3、逃跑
            - 退出游戏，显示提示信息，游戏结束！
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 显示欢迎信息
print('-'*20,'欢迎光临《唐僧大战白骨精》','-'*20)

# 显示身份选择的信息
print('请选择你的身份：')
print('\t1.唐僧')
print('\t2.白骨精')
# 游戏的身份选择
player_choose = input('请选择[1-2]：')

# 打印一条分割线
print('-'*66)

# 根据用户的选择来显示不同的提示信息
if player_choose == '1':
    # 选择1
    print('你已经选择了1，你将以->唐僧<-的身份来进行游戏！')
elif player_choose == '2':
    # 选择2
    print('你竟然选择了白骨精，太不要脸了，你将以->唐僧<-的身份来进行游戏！')
else :
    # 选择3
    print('你的输入有误，系统将自动分配身份，你将以->唐僧<-的身份来进行游戏！')

# 进入游戏

# 创建变量，来保存玩家的生命值和攻击力
player_life = 2 # 生命值
player_attack = 2 # 攻击力

# 创建一个变量，保存boss的生命值和攻击力
boss_life = 10
boss_attack = 10

# 打印一条分割线
print('-'*66)
# 显示玩家的信息（攻击力、生命值）
print(f'唐僧，你的生命值是 {player_life} , 你的攻击力是 {player_attack}')

# 由于游戏选项是需要反复显示的，所以必须将其编写到一个循环中
while True :
    # 打印一条分割线
    print('-'*66)
    # 显示游戏选项，游戏正式开始
    print('请选择你要进行的操作：')
    print('\t1.练级')
    print('\t2.打BOSS')
    print('\t3.逃跑')
    game_choose = input('请选择要做的操作[1-3]：')

    # 处理用户的选择
    if game_choose == '1' :
        # 增加玩家的生命值和攻击力
        player_life += 2
        player_attack += 2
        # 显示最新的信息
        # 打印一条分割线
        print('-'*66)
        # 显示玩家的信息（攻击力、生命值）
        print(f'恭喜你升级了！，你现在的生命值是 {player_life} , 你的攻击力是 {player_attack}')
    elif game_choose == '2' :
        # 玩家攻击boss
        # 减去boss的生命值，减去的生命值应该等于玩家的攻击力
        boss_life -= player_attack 

        # 打印一条分割线
        print('-'*66)
        print('->唐僧<- 攻击了 ->白骨精<-')
        # 检查boss是否死亡
        if boss_life <= 0 :
            # boss死亡，player胜利，游戏结束
            print(f'->白骨精<-受到了 {player_attack} 点伤害，重伤不治死了，->唐僧<-赢得了胜利！')
            # 游戏结束
            break

        # boss要反击玩家
        # 减去玩家的生命值
        player_life -= boss_attack 
        print(' ->白骨精<- 攻击了 ->唐僧<-')
        # 检查玩家是否死亡
        if player_life <= 0 :
            # 玩家死亡
            print(f'你受到了 {boss_attack} 点伤害，重伤不治死了！GAME OVER')
            # 游戏结束
            break
    elif game_choose == '3' :
        # 打印一条分割线
        print('-'*66)
        # 逃跑，退出游戏
        print('->唐僧<-一扭头，撒腿就跑！GAME OVER')
        break
    else :
        # 打印一条分割线
        print('-'*66)
        print('你的输入有误，请重新输入！')



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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

数据结构

列表（list）

列表是Python中的一个对象。
对象（object）是内存中专门用来存储数据的一块区域。
对象、数值只能保存一个单一的数据。

列表中可以保存多个有序的数据。
列表是用来存储对象的对象
1
2
3
4
5
6

列表的使用：
1.列表的创建。
2.操作列表中的数据。
1
2
3

练习：创建一个列表，在列表中保存你最好的5个朋友的名字，然后分别通过索引来获取每一个朋友的名字。
1

code example：

# 创建列表，通过[]创建列表
my_list = [] # 创建一个空列表
#print(my_list , type(my_list)) #print:[] <class 'list'>

# 列表存储的数据，称为元素。
# 一个列表中可以存储多个元素，可以在创建列表时，来指定列表中的元素。
my_list = [10] # 创建一个只包含一个元素的列表。
#print(my_list) #print:[10]

# 当向列表中添加多个元素时，多个元素之间使用,隔开
my_list = [10,20,30,40,50] # 创建一个有5个元素的列表。
#print(my_list) #print:[10, 20, 30, 40, 50]

# 列表中可以保存任意的对象
my_list = [10, 'hello', True, None, [1, 2, 3], print]
#print(my_list) #print:[10, 'hello', True, None, [1, 2, 3], <built-in function print>]

# 列表中的对象都会按照插入的顺序存储到列表中，第一个插入的对象保存到第一个位置，第二个保存到第二个位置。
# 可以通过索引（index）来获取列表中的元素。
#     索引是元素在列表中的位置，列表中的每一个元素都有一个索引。
#     索引是从0开始的整数，列表第一个位置索引为0，第二个位置索引为1，第三个位置索引为2，。。。。。。
my_list = [10,20,30,40,50]

# 通过索引获取列表中的元素
# 语法：my_list[索引] my_list[0]

#print(my_list[4]) #print:50

# 如果使用的索引超过了最大的范围，会抛出异常
#print(my_list[5]) IndexError: list index out of range

# 获取列表的长度（列表中元素的个数）
# len()函数，通过该函数可以获取列表的长度
# 获取到的长度的值是列表的最大索引 + 1
print(len(my_list)) #print:5
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
35

切片

# 切片
# 切片指从现有列表中，获取一个子列表。
# 创建一个列表，一般创建列表时，变量的名字会使用复数。
students = ['宋江','卢俊义','吴用','公孙胜','关胜','林冲']

#print(students[2]) #print:吴用

# 列表的索引可以是负数
# 如果索引是负数，则从后向前获取元素，-1表示倒数第一个，-2表示倒数第二个，。。。。。。
#print(students[-2]) #print:关胜

# 通过切片来获取指定的元素。
# 语法：列表[起始:结束] 
#     通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素。
#     做切片操作时，总会返回一个新的列表，不会影响原来的列表。
#     起始和结束位置的索引都可以省略不写。
#     如果省略结束位置，则会一直截取到最后。
#     如果省略起始位置，则会从第一个元素开始截取。
#     如果起始位置和结束位置全部省略，则相当于创建了一个列表的副本。
#print(students[0 : 2]) #print:['宋江', '卢俊义']
#print(students[1:]) #print:['卢俊义', '吴用', '公孙胜', '关胜', '林冲']
#print(students[:3]) #print:['宋江', '卢俊义', '吴用']
#print(students[:]) #print:['宋江', '卢俊义', '吴用', '公孙胜', '关胜', '林冲']
#print(students) #print:['宋江', '卢俊义', '吴用', '公孙胜', '关胜', '林冲']

# 语法：列表[起始:结束:步长] 
# 步长表示，每次获取元素的间隔，默认值是1
#print(students[0:5:3]) #print:['宋江', '公孙胜']
#print(students[::3]) #print:['宋江', '公孙胜']

# 步长不能是0，但是可以是负数
#print(stus[::0]) ValueError: slice step cannot be zero

# 如果是负数，则会从列表的后部向前边取元素
#print(students[::-1]) #print:['林冲', '关胜', '公孙胜', '吴用', '卢俊义', '宋江']
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
35

通用操作

# + 和 *
# +可以将两个列表拼接为一个列表
my_list = [1,2,3] + [4,5,6]
#print(my_list) #print:[1, 2, 3, 4, 5, 6]
# * 可以将列表重复指定的次数
my_list = [1,2,3] * 5
#print(my_list) #print:[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

# 创建一个列表
students = ['宋江','卢俊义','吴用','公孙胜','关胜','林冲','秦明','呼延灼']

# in 和 not in
# in用来检查指定元素是否存在于列表中。如果存在，返回True，否则返回False。
# not in用来检查指定元素是否不在列表中。如果不在，返回True，否则返回False。
#print('宋江' in students) #print:True
#print('宋江' not in students) #print:False

# len()获取列表中的元素的个数。

# min() 获取列表中的最小值。
# max() 获取列表中的最大值。
arr = [10,1,2,5,100,77]
#print(min(arr) , max(arr)) #print:1 100
#print(len(arr)) #print:6

# 两个方法（method），方法和函数基本上一样，只不过方法必须通过 对象.方法()的形式调用
# xxx.print() 方法实际上就是和对象关系紧密的函数。
# s.index() 获取指定元素在列表中的第一次出现时索引

print(students.index('宋江')) #print:0

# index()的第二个参数，表示查找的起始位置 ， 第三个参数，表示查找的结束位置

print(students.index('关胜',3,6)) #print:4

# 如果要获取列表中没有的元素，会抛出异常
#print(students.index('花荣')) ValueError: '牛魔王' is not in list
# s.count() 统计指定元素在列表中出现的次数
print(students.count('宋江')) #print:1
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
35
36
37
38
39

序列（sequence）

序列是Python中最基本的一种数据结构。
数据结构指计算机中数据存储的方式。
序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引），并且序列中的数据会按照添加的顺序来分配索引。

序列的分类：
    可变序列（序列中的元素可以改变）：
        >列表（list）
    不可变序列（序列中的元素不能改变）：
        >字符串（str）    
        >元组（tuple）
1
2
3
4
5
6
7
8
9
10

修改元素

# 创建一个列表
students = ['宋江','卢俊义','吴用','公孙胜','关胜','林冲']

#print("修改前：", students) #print:修改前： ['宋江', '卢俊义', '吴用', '公孙胜', '关胜', '林冲']

# 修改列表中的元素
# 直接通过索引来修改元素
#students[0] = '秦明'
#students[2] = '呼延灼'
#print(students) print:['秦明', '卢俊义', '呼延灼', '公孙胜', '关胜', '林冲']
# 通过del来删除元素

#del students[2] # 删除索引为2的元素

#print('修改后：',students) #print:修改后： ['宋江', '卢俊义', '公孙胜', '关胜', '林冲']

stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']

# print("修改前：",stus)

# 通过切片来修改列表
# 在给切片进行赋值时，只能使用序列
# stus[0:2] = ['牛魔王','红孩儿'] 使用新的元素替换旧元素
# stus[0:2] = ['牛魔王','红孩儿','二郎神']
# stus[0:0] = ['牛魔王'] # 向索引为0的位置插入元素
# 当设置了步长时，序列中元素的个数必须和切片中元素的个数一致
# stus[::2] = ['牛魔王','红孩儿','二郎神']

# 通过切片来删除元素
# del stus[0:2]
# del stus[::2]
# stus[1:3] = []

# print('修改后：',stus)

# 以上操作，只适用于可变序列
s = 'hello'
# s[1] = 'a' 不可变序列，无法通过索引来修改
# 可以通过 list() 函数将其他的序列转换为list
s = list(s)
print(s)
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
35
36
37
38
39
40
41

列表的方法

# 列表的方法
students = ['宋江', '卢俊义', '吴用', '公孙胜']
print('原列表：', students);


# append() 向列表的最后添加一个元素
students.append('关胜')
print('将关胜添加至列表的最后：', students)


# insert() 向列表的指定位置插入一个元素
# 参数：1、插入的位置 2、插入的元素
students.insert(2, '林冲')
print(students)

# extend() 使用新的序列来扩展当前序列
# 需要一个序列作为参数，它会将该序列中的元素添加到当前列表中
students.extend(['秦明', '呼延灼'])
print(students)

# clear() 清空序列
students.clear()
print(students)

# pop() 根据索引删除并返回被删除的元素
students = ['宋江', '卢俊义', '吴用', '公孙胜']
result = students.pop(2) # 删除索引为2的元素
print(students)
print(result)

# pop()如果不指定参数，则删除列表的最后一个元素
result = students.pop() # 删除列表的最后一个元素
print(students)
print('result=', result)

# remove() 删除指定值的元素，如果相同值的元素有多个，只会删除第一个
students = ['宋江', '卢俊义', '吴用', '公孙胜', '吴用']
result = students.remove('吴用')
print(students)
print(result) #返回值为None

# reverse() 反转列表
students.reverse()
print(students)

# sort() 对列表中的元素进行排序，默认是升序排列。如果需要降序排列，则需要传递一个reverse=True作为参数。
# 对字母和数字排序。
my_list = list('helloworld')
print('修改前：', my_list)
my_list.sort();
print('修改后：', my_list)

my_list = [10, 1, 20, 3, 4, 5, 0, -2]
print('修改前', my_list)
my_list.sort(reverse=True)
print('修改后', my_list)
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

遍历列表

# 遍历列表：将列表中的所有元素取出来
# 创建列表
students = ['宋江', '卢俊义', '吴用', '公孙胜', '关胜', '林冲']

# 遍历列表
print(students[0])
print(students[1])
print(students[2])
print(students[3])
print(students[4])
print(students[5])

print('********************')

# 通过while循环来遍历列表
i = 0
while i < len(students) :
    print(students[i])
    i += 1

print('********************')

# 通过for循环来遍历列表
# 语法：
#    for 变量 in 序列 :
#        代码块
# for循环的代码块会执行多次，序列中有几个元素就会执行几次，每执行一次就会将序列中的一个元素赋值给变量，所以可以通过变量，来获取列表中的元素。
for s in students :
    print(s)
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

练习

EMS（Employee Manager System，员工管理系统）

命令行版本的员工管理系统
功能：
    1、查询：显示当前系统中的所有员工
    2、添加：将员工添加到当前系统中
    3、删除：将员工从系统中删除
    4、退出：退出系统
1
2
3
4
5
6

# 显示系统的欢迎信息
print('-'*20 , '欢迎使用员工管理系统', '-'*20)
# 创建一个列表，用来保存员工的信息，员工的信息以字符串的形式统一保存到列表
emps = ['孙悟空\t18\t男\t花果山','猪八戒\t28\t男\t高老庄']

# 创建一个死循环
while True:
    # 显示用户的选项
    print('请选择要做的操作：')
    print('\t1.查询员工')
    print('\t2.添加员工')
    print('\t3.删除员工')
    print('\t4.退出系统')
    user_choose = input('请选择[1-4]:')
    print('-'*62)
    # 根据用户的选择做相关的操作
    if user_choose == '1' :
        # 查询员工
        # 打印表头
        print('\t序号\t姓名\t年龄\t性别\t住址')
        # 创建一个变量，来表示员工的序号
        n = 1
        # 显示员工信息
        for emp in emps :
            print(f'\t{n}\t{emp}')
            n += 1
    elif user_choose == '2':
        # 添加员工
        # 获取要添加员工的信息，姓名、年龄、性别、住址
        emp_name = input('请输入员工的姓名：')
        emp_age = input('请输入员工的年龄：')
        emp_gender = input('请输入员工的性别：')
        emp_address = input('请输入员工的住址：')

        # 创建员工信息
        # 将四个信息拼接为一个字符串，然后插入到列表中
        emp = f'{emp_name}\t{emp_age}\t{emp_gender}\t{emp_address}'
        # 显示一个提示信息
        print('以下员工将被添加到系统中')
        print('-'*62)
        print('姓名\t年龄\t性别\t住址')
        print(emp)
        print('-'*62)
        user_confirm = input('是否确认该操作[Y/N]:')

        # 判断
        if user_confirm == 'y' or user_confirm == 'yes' :
            # 确认
            emps.append(emp)
            # 显示提示信息
            print('添加成功！')
        else :
            # 取消操作
            print('添加已取消！')
        
    elif user_choose == '3':
        # 删除员工，根据员工的序号来删除员工
        # 获取要删除的员工的序号
        del_num = int(input('请输入要删除的员工的序号：'))

        # 判断序号是否有效
        if 0 < del_num <= len(emps) :
            # 输入合法，根据序号来获取索引
            del_i = del_num - 1
            # 显示一个提示信息
            print('以下员工将被删除')
            print('-'*62)
            print('\t序号\t姓名\t年龄\t性别\t住址')
            print(f'\t{del_num}\t{emps[del_i]}')
            print('-'*62)
            user_confirm = input('该操作不可恢复，是否确认[Y/N]:')
            # 判断
            if user_confirm == 'y' or user_confirm == 'yes' :
                # 删除元素
                emps.pop(del_i)
                # 显示提示
                print('员工已被删除！')
            else :
                # 操作取消
                print('操作已取消！')
        else :
            # 输入有误
            print('您的输入有误，请重新操作！')

    elif user_choose == '4':
        # 退出
        print('欢迎使用！再见!')
        input('点击回车键退出！')
        break
    else :
        print('您的输入有误，请重新选择！')

    # 打印分割线
    print('-'*62)
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

range

# range()是一个函数，用来生成一个自然数的序列。
# 该函数需要三个参数：
#   1.起始位置（可以省略，默认是0）
#   2.结束位置
#   3.步长（可以省略，默认是1）
r = range(5) # 生成一个这样的序列[0, 1, 2, 3, 4]
print(list(r)) # print:[0, 1, 2, 3, 4]
 
r = range(0, 10, 2) # print:[0, 2, 4, 6, 8]
print(list(r))
r = range(10, 0, -1)
print(list(r)) # print:[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]


# 通过range()可以创建一个执行指定次数的for循环
# for()循环除了创建方式以外，其余的都和while一样，包括else、包括break continue都可以在for循环中使用。
for i in range(5) :
    print(i)

for s in 'hello' :
    print(s)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

元组

# 元组(tuple)
# 元组是一个不可变的序列
# 它的操作的方式基本上和列表是一致的
# 所以在操作元组时，就把元组当成是一个不可变的列表就可以了
# 一般希望数据不改变时，使用元组，其余情况都使用列表。

# 创建元组：使用()来创建元组
my_tuple = () # 创建一个空元组
print(my_tuple, type(my_tuple)) # () <class 'tuple'>

my_tuple = (1, 2, 3, 4, 5) # 创建了一个5个元素的元组

# 元组是不可变对象，不能尝试为元组中的元素重新赋值
# my_tuple[3] = 10 TypeError: 'tuple' object does not support item assignment

print(my_tuple[3]) # print:4

# 当元组不是空元组时，括号可以省略
# 如果元组不是空元组，它里边至少要有一个,
my_tuple = 10, 20, 30, 40
print(my_tuple) # (10, 20, 30, 40)

my_tuple = 40,
print(my_tuple , type(my_tuple)) # (40,) <class 'tuple'>

my_tuple = 10, 20, 30, 40

# 元组的解包（解构）
# 解包指就是将元组当中每一个元素都赋值给一个变量
a, b, c, d = my_tuple

print("a =", a) # print:a = 10
print("b =", b) # print:b = 20
print("c =", c) # print:c = 30
print("d =", d) # print:d = 40

a = 100
b = 200
print(a , b) # print:100 200

# 交互a和b的值，可以利用元组的解包
a, b = b, a
print(a , b) # print:200 100


my_tuple = 10 , 20 , 30 , 40
# 对一个元组进行解包时，变量的数量必须和元组中的元素的数量一致
# 也可以在变量前边添加一个*，这样变量将会获取元组中所有剩余的元素
a, b, *c = my_tuple
print('a =', a) #print:a = 10
print('b =', b) #print:b = 20
print('c =', c) #print:c = [30, 40]

a, *b, c = my_tuple
print('a =', a) #print:a = 10
print('b =', b) #print:b = [20, 30]
print('c =', c) #print:c = 40

*a, b, c = my_tuple
print('a =', a) #print:a = [10, 20]
print('b =', b) #print:b = 30
print('c =', c) #print:c = 40

a, b, *c = [1, 2, 3, 4, 5, 6, 7]
print('a =', a) #print:a = 1
print('b =', b) #print:b = 2
print('c =', c) #print:c = [3, 4, 5, 6, 7]

a, b, *c = 'hello world'
print('a =', a) #print:a = h
print('b =', b) #print:b = e
print('c =', c) #print:c = ['l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

# 不能同时出现两个或两个以上的*变量
# *a, *b, c = my_tuple SyntaxError: two starred expressions in assignment
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

可变对象

每个对象中都保存了三个数据：id（标识）、type（类型）、value（值）    

列表就是一个可变对象，a = [1,2,3]
a[0] = 10 （改对象）
此操作通过变量去修改对象的值，这种操作不会改变变量所指向的对象。    
当去修改对象时，如果有其他变量也指向了该对象，则修改也会在其他的变量中体现。

a = [4, 5, 6]（改变量）
这个操作是在给变量重新赋值
这种操作会改变变量所指向的对象
为一个变量重新赋值时，不会影响其他的变量

一般只有在为变量赋值时才是修改变量，其余的都是修改对象。
1
2
3
4
5
6
7
8
9
10
11
12
13

# 可变对象
a = [1, 2, 3]
print('修改前：', a, id(a))

# 通过索引修改列表
a[0] = 10
print('修改后：', a , id(a))

# 为变量重新赋值
a = [4, 5, 6]
print('修改后：', a , id(a))

print('********************************')
a = [1, 2, 3]
b = a
print('a', a, id(a))
print('b',b,id(b))

b[0] = 10
print('a', a, id(a))
print('b', b, id(b))

b = [10, 2, 3]
print('a', a, id(a))
print('b', b, id(b))

print('================================')

# ==、!=、is、is not
# ==、!=：比较对象的值是否相等 
# is、is not：比较对象的id是否相等（比较两个对象是否是同一个对象）

a = [1, 2, 3]
b = [1, 2, 3]
print(a, b)
print(id(a), id(b))

print(a == b) # a和b的值相等，使用==会返回True
print(a is b) # a和b不是同一个对象，内存地址不同，使用is会返回False
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
35
36
37
38
39

字典（dictionary）

字典属于一种新的数据结构，称为映射（mapping）。

字典的作用和列表类似，都是用来存储对象的容器。
列表存储数据的性能比较好，但查询数据的性能的比较差。

在字典中每个元素都有唯一的名字，通过这个唯一的名字可以快速的查找到指定的元素。
在查询元素时，字典的效率非常快。

在字典中可以保存多个对象，每个对象都会有一个唯一的名字。
这个唯一的名字，称为键（key），通过key可以快速的查询value。
这个对象，称为值（value）。
所以字典是键值对（key-value）结构。
每个字典中都可以有多个键值对，而每一个键值对称为一项（item）。
1
2
3
4
5
6
7
8
9
10
11
12
13

# 字典
# 使用{}来创建字典
d = {} # 创建一个空字典
print(d, type(d)) #print:{} <class 'dict'>

# 创建一个包含数据的字典
# 语法：{key:value, key:value, key:value}
# 字典的值可以是任意对象
# 字典的键可以是任意的不可变对象（int、str、bool、tuple ......）
# 字典的键是不能重复的，如果出现重复，后边的会替换掉前面的
#d = {'name':'宋江', 'age':50, 'gender':'男', 'name':'jack'}
d = {
	'name':'宋江' , 
	'age':50 , 
	'gender':'男' , 
	'name':'jack'
}
print(d, type(d)) #print:{'name': 'jack', 'age': 50, 'gender': '男'} <class 'dict'>

# 根据键来获取值
print(d['name'], d['age'], d['gender']) #print:jack 50 男

# 如果使用了字典中不存在的键，会报错。比如：print(d['hello'])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 创建字典
# 使用{}
# 语法：{k1:v1,k2:v2,k3:v3}

# 使用 dict()函数来创建字典
# 每一个参数都是一个键值对，参数名就是键，参数名就是值（这种方式创建的字典，key都是字符串）
d = dict(name='孙悟空',age=18,gender='男') 

# 也可以将一个包含有双值子序列的序列转换为字典
# 双值序列，序列中只有两个值，[1,2] ('a',3) 'ab'
# 子序列，如果序列中的元素也是序列，那么我们就称这个元素为子序列
# [(1,2),(3,5)]
d = dict([('name','孙悟饭'),('age',18)])
# print(d , type(d))
d = dict(name='孙悟空',age=18,gender='男') 

# len() 获取字典中键值对的个数
# print(len(d))

# in 检查字典中是否包含指定的键
# not in 检查字典中是否不包含指定的键
# print('hello' in d)

# 获取字典中的值，根据键来获取值
# 语法：d[key]
# print(d['age'])

# n = 'name'
# print(d[n])

# 通过[]来获取值时，如果键不存在，会抛出异常 KeyError
# get(key[, default]) 该方法用来根据键来获取字典中的值
#   如果获取的键在字典中不存在，会返回None
#   也可以指定一个默认值，来作为第二个参数，这样获取不到值时将会返回默认值
# print(d.get('name'))
# print(d.get('hello','默认值'))

# 修改字典
# d[key] = value 如果key存在则覆盖，不存在则添加
d['name'] = 'sunwukong' # 修改字典的key-value
d['address'] = '花果山' # 向字典中添加key-value

# print(d)
# setdefault(key[, default]) 可以用来向字典中添加key-value
#   如果key已经存在于字典中，则返回key的值，不会对字典做任何操作
#   如果key不存在，则向字典中添加这个key，并设置value
result = d.setdefault('name','猪八戒')
result = d.setdefault('hello','猪八戒')

# print('result =',result)
# print(d)

# update([other])
# 将其他的字典中的key-value添加到当前字典中
# 如果有重复的key，则后边的会替换到当前的
d = {'a':1,'b':2,'c':3}
d2 = {'d':4,'e':5,'f':6, 'a':7}
d.update(d2)

# print(d)
# 删除，可以使用 del 来删除字典中的 key-value
del d['a']
del d['b']

# popitem()
# 随机删除字典中的一个键值对，一般都会删除最后一个键值对
#   删除之后，它会将删除的key-value作为返回值返回
#   返回的是一个元组，元组中有两个元素，第一个元素是删除的key，第二个是删除的value
# 当使用popitem()删除一个空字典时，会抛出异常 KeyError: 'popitem(): dictionary is empty'
# d.popitem()
# result = d.popitem()

# pop(key[, default])
# 根据key删除字典中的key-value
# 会将被删除的value返回！
# 如果删除不存在的key，会抛出异常
#   如果指定了默认值，再删除不存在的key时，不会报错，而是直接返回默认值
result = d.pop('d')
result = d.pop('z','这是默认值')

# del d['z'] z不存在，报错
# result = d.popitem()
# result = d.popitem()
# result = d.popitem()
# result = d.popitem()

# clear()用来清空字典
d.clear()

# print('result =',result)
# print(d)

# copy()
# 该方法用于对字典进行浅复制
# 复制以后的对象，和原对象是独立，修改一个不会影响另一个
# 注意，浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制
d = {'a':1,'b':2,'c':3}
d2 = d.copy()
# d['a'] = 100

d = {'a':{'name':'孙悟空','age':18},'b':2,'c':3}
d2 = d.copy()
d2['a']['name'] = '猪八戒'


print('d = ',d , id(d))
print('d2 = ',d2 , id(d2))
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

遍历字典

# 遍历字典

# keys() 返回字典的所有的key。该方法会返回一个序列，序列中保存的是字典的所有的键。
d = {'name':'宋江', 'age':50, 'gender':'男'}
print(d.keys()) #print:dict_keys(['name', 'age', 'gender'])

# 通过遍历keys()来获取所有的键。
for k in d.keys() :
    print(k, d[k])

# values() 返回一个序列，序列中保存有字典的所有的值
for v in d.values():
    print(v)

# items() 返回字典中所有的项。会返回一个序列，序列中包含有双值子序列。
# 双值分别是字典中的key和value。
print(d.items()) #print:dict_items([('name', '宋江'), ('age', 50), ('gender', '男')])

for k, v in d.items() :
    print(k, '=', v)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

集合（set）

集合和列表非常相似。

不同点：
1.集合中只能存储不可变对象。
2.集合中存储的对象是无序（不是按照元素的插入顺序保存）的。
3.集合中不能出现重复的元素。
1
2
3
4
5
6

# 集合
# 使用{}创建集合
s = {10, 3, 5, 1, 2, 1, 2, 3, 1, 1, 1, 1} #set() <class 'set'>

print(s, type(s)) #print:{1, 2, 3, 5, 10} <class 'set'>

#s = {[1,2,3], [4,6,7]} #TypeError: unhashable type: 'list'

# 使用set()创建集合
s = set() # 创建空集合

# 可以通过set()将序列和字典转换为集合
s = set([1, 2, 3, 4, 5, 1, 1, 2, 3, 4, 5])
print(s, type(s)) #print:{1, 2, 3, 4, 5} <class 'set'>
s = set('hello')
print(s, type(s)) #print:{'h', 'l', 'e', 'o'} <class 'set'>
s = set({'a':1, 'b':2, 'c':3}) # 使用set()将字典转换为集合时，只会包含字典中的键。
print(s, type(s)) #print:{'c', 'b', 'a'} <class 'set'>

# 创建集合
s = {'a', 'b', 1, 2, 3, 1}

# 使用in和not in来检查集合中的元素
print('c' in s) #print:False

# len() 获取集合中元素的数量。
print(len(s)) #print:5

# add() 向集合中添加元素
s.add(10)
s.add(30)
print(s) #print:{1, 2, 3, 'b', 10, 'a', 30}

print("*******************")

# update()将一个集合中的元素添加到当前集合中。
# update()可以传递序列或字典作为参数，字典只会使用键。
s2 = set('hello')
s.update(s2)
print(s) #print:{'e', 1, 2, 3, 10, 'l', 'b', 'a', 'h', 'o', 30}

s.update((10, 20, 30, 40, 50))
print(s) #print:{'e', 1, 2, 3, 40, 10, 'l', 50, 20, 'b', 'a', 'h', 'o', 30}

s.update({10:'ab', 20:'bc', 100:'cd', 1000:'ef'})
print(s) #print:{'e', 1, 2, 3, 100, 40, 1000, 10, 'l', 50, 20, 'b', 'a', 'h', 'o', 30}

# pop() 随机删除并返回一个集合中的元素
result = s.pop()
print(result) #print:1

# remove()删除集合中的指定元素
s.remove(100)
s.remove(1000)

# clear()清空集合
s.clear()
print(s, type(s)) #print:set() <class 'set'>

# copy() 对集合进行浅复制
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

集合的运算：

# 对集合做运算时，不会影响原来的集合，而是返回一个运算结果。
# 创建两个集合
s = {1, 2, 3, 4, 5}
s1 = {3, 4, 5, 6, 7}

# & 交集运算
result = s & s1
print('result =', result) #print:result = {3, 4, 5}

# | 并集运算
result = s | s1
print('result =', result) #print:result = {1, 2, 3, 4, 5, 6, 7}

# - 差集
result = s - s1
print('result = ', result) #print:result =  {1, 2}

# ^ 异或集 获取只在一个集合中出现的元素
result = s ^ s1 
print('result = ', result) #print:result =  {1, 2, 6, 7}

# <= 检查一个集合是否是另一个集合的子集。
# 如果a集合中的元素全部都在b集合中出现，那么a集合就是b集合的子集，b集合是a集合的超集。
a = {1,2,3}
b = {1,2,3,4,5}

result = a <= b 
print(result) #print:True
result = {1, 2, 3} <= {1, 2, 3} 
print(result) #print:True
result = {1, 2, 3, 4, 5} <= {1, 2, 3} 
print(result) #print:False

# < 检查一个集合是否是另一个集合的真子集
# 如果超集b中含有子集a中所有元素，并且b中还有a中没有的元素，则b就是a的真超集，a是b的真子集。
result = {1,2,3} < {1,2,3} 
print(result) #print:False
result = {1,2,3} < {1,2,3,4,5} 
print(result) #print:True

# >= 检查一个集合是否是另一个集合的超集。
# > 检查一个集合是否是另一个集合的真超集。
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
35
36
37
38
39
40
41
42

exercise problems

编码题

examination questions:
使用二维列表保存学生信息，如表

姓名	年龄	性别	年级	班级	成绩
李敏	15	男	7	2	3.4
赵四	16	男	8	1	4.0
李艳	15	女	8	1	3.3
张晓	17	女	8	3	4.2

将李敏和赵四的信息在创建阶段就加入到列表中。
将李艳的信息加入到列表中，放到列表的末尾。
将张晓的信息加入到列表中索引中为0的位置上。
将列表中的学生信息输出到控制台上。

solution:

student_information = [

	['李敏', 15, '男', 7, 2, 3.4],
	['赵四', 16, '男', 8, 1, 4.0],
	['李艳', 15, '女', 8, 1, 3.3],
	['张晓', 17, '女', 8, 3, 4.2]

]

print(student_information)
print(type(student_information))

print('************')

student_information1 = [

	['李敏', 15, '男', 7, 2, 3.4],
	['赵四', 16, '男', 8, 1, 4.0]

]

print(student_information1)

student_information1.append(['李艳', 15, '女', 8, 1, 3.3])
print(student_information1)

student_information1.insert(0, ['张晓', 17, '女', 8, 3, 4.2])
print(student_information1)

print('******************************')

for student in student_information1:
		#print(student)
		#print(type(student))	
		print('%s的信息是'%student[0])
		print('%d岁，%s性，%d年级%d班，成绩%.1f'%(student[1], student[2], student[3], student[4], student[5]))
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
35
36

使用表中的学生信息构造二维列表，然后对二维列表中的学生信息进行排序，排序后要求学生成绩按照从小到大的顺序排列，最后将排序后的学生信息输出到控制台上。

函数与模块

函数（function）简介

函数也是一个对象。
对象是内存中专门用来存储数据的一块区域。
函数可以用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次的调用。

创建函数：
def 函数名([形式参数1, 形式参数2, … 形式参数n]) :
代码块

函数名必须要符合标识符的规范（可以包含字母、数字、下划线、但不能以数字开头）。

函数中保存的代码不会立即执行，需要调用函数代码才会执行。

调用函数：函数对象()
定义函数一般都是要实现某种功能的。

函数的参数：
在定义函数时，可以在函数名后的()中定义数量不等的形参，多个形参之间使用,隔开。

形参（形式参数），定义形参就相当于在函数内部声明了变量，但是并不赋值。

实参（实际参数），如果函数定义时，指定了形参，那么在调用函数时也必须传递实参，实参将会赋值给对应的形参，有几个形参就得传几个实参。

# 比如有如下三行代码，这三行代码是一个完整的功能。
"""
print('Hello')
print('你好')
print('再见')
"""

# 定义一个函数
def fn() :
    print('这是我的第一个函数！')
    print('hello')
    print('今天天气真不错！')

# 打印fn
print(fn) #print:<function fn at 0x010DB6F0>
print(type(fn)) #print:<class 'function'>

# fn是函数对象；fn()调用函数。
# print是函数对象；print()调用函数。
fn()

# 定义一个函数，用来求任意两个数的和。
def sum() :
    a = 1
    b = 2
    print(a + b)

sum() #print:3

# 定义函数时指定形参
def fn1(a, b) :
    
    print('a =',a)
    print('b =',b)
    print(a, "+", b, "=", a + b)

# 调用函数时，传递实参
fn1(2, 3)
fn1(3, 4)
"""
print:
a = 2
b = 3
2 + 3 = 5
a = 3
b = 4
3 + 4 = 7
"""
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48

# 求任意三个数的乘积；定义一个函数，用来求任意三个数的乘积。
def mul(a, b, c) :
    print(a * b * c)

# 根据不同的用户名显示不同的欢迎信息；定义一个函数，根据不同的用户名显示不同的欢迎信息。 
def welcome(username) :
    print('欢迎', username, '光临')

mul(1, 2, 3) #print:6  
welcome('孙悟空') #print:欢迎 孙悟空 光临

# 定义一个函数
# 定义形参时，可以为形参指定默认值。指定了默认值以后，如果用户传递了参数则默认值没有任何作用，如果用户没有传递，则默认值就会生效。
def fn(a = 1, b = 2, c = 3):
    print('a =', a)
    print('b =', b)
    print('c =', c)

fn(4, 5, 6)
fn(7, 8)
fn() 

"""
print:
a = 4
b = 5
c = 6
a = 7
b = 8
c = 3
a = 1
b = 2
c = 3
"""

# 实参的传递方式
# 位置参数
# 位置参数就是将对应位置的实参复制给对应位置的形参
# 第一个实参赋值给第一个形参，第二个实参赋值给第二个形参。。。。。。
fn(10 , 20 , 30)
"""
print:
a = 10
b = 20
c = 30
"""

print("************************")

#关键字参数，可以不按照形参定义的顺序去传递，而直接根据参数名去传递参数
fn(b=1, c=2, a=3)
"""
a = 3
b = 1
c = 2
"""
print('hello', end='') #print:helloa = 1

#位置参数和关键字参数可以混合使用，混合使用关键字和位置参数时，必须将位置参数写到前面
fn(1, c=30)
"""
b = 2
c = 30
"""
def fn2(a):
    print('a =', a) 

print('=========================================')

# 函数在调用时，解析器不会检查实参的类型。
# 实参可以传递任意类型的对象。
#b = 123
#b = True
#b = 'hello'
#b = None
b = [1, 2, 3]

fn2(b)    
fn2(fn) #print:a = <function fn at 0x01D71A50>

def fn3(a, b):
    print(a + b)

#fn3(11, "22") #错误

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

def fn4(a):
    # 在函数中对形参进行重新赋值，不会影响其他的变量
    # a = 20
    # a是一个列表，尝试修改列表中的元素
    # 如果形参执行的是一个对象，当我们通过形参去修改对象时，会影响到所有指向该对象的变量
    a[0] = 30
    print('a =', a, id(a))

#c = 10   
c = [1, 2, 3] 

#fn4(c)
#fn4(c.copy())
fn4(c[:])

print('c =', c, id(c))
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

不定长参数

# 不定长的参数
# 定义一个函数，求任意个数字的和。
def sum(*numbers) :
    # 定义一个变量，用来保存结果
    result = 0
    # 遍历元组，并将元组中的数进行累加
    for number in numbers :
        result += number
    
    print(result)

sum(1, 2, 3, 4) #print:10

# 定义函数时，可以在形参前边加上一个*，这样这个形参将会获取到所有的实参。它将所有的实参保存到一个元组中。
a, b, *c = (1, 2, 3, 4, 5, 6)
# *a会接收所有的位置实参，并且会将这些实参统一保存到一个元组中（装包）
def function(*a) :
    print("a=", a, type(a))

function(1, 2, 3, 4, 5) #print:a= (1, 2, 3, 4, 5) <class 'tuple'>

# 带星号的形参只能有一个
# 带星号的参数，可以和其他参数配合使用
# 第一个参数给a，第二个参数给b，剩下的都保存到c的元组中
def function1(a, b, *c) :
    print('a=', a, 'b=', b, 'c=', c)

function1(1, 2, 3, 4, 5) #print:a= 1 b= 2 c= (3, 4, 5)

# 可变参数不是必须写在最后，但是注意，带*的参数后的所有参数，必须以关键字参数的形式传递
# 第一个参数给a，剩下的位置参数给b的元组，c必须使用关键字参数。
def function2(a, *b, c) :
    print('a=', a, 'b=', b, 'c=', c)

function2(1, 2, 3, 4, c=5) #print:a= 1 b= (2, 3, 4) c= 5

# 所有的位置参数都给a，b和c必须使用关键字参数
def function3(*a, b, c):
    print('a=', a, 'b=', b, 'c=', c)

function3(1, 2, 3, b=4, c=5) #print:a= (1, 2, 3) b= 4 c= 5

# 如果在形参的开头直接写一个*,则所有的参数必须以关键字参数的形式传递
def function4(*, a, b, c):
    print('a=', a, 'b=', b, 'c=', c)

function4(a=1, b=2, c=3) #print:a= 1 b= 2 c= 3
function4(a=1, b=2, c=3) #print:a= 1 b= 2 c= 3
# *形参只能接收位置参数，而不能接收关键字参数
def function5(*a) :
    print('a=', a)

function5(1, 2, 3, 4, 5) #print:a= (1, 2, 3, 4, 5)

"""
**形参可以接收其他的关键字参数，它会将这些参数统一保存到一个字典中
字典的key就是参数的名字，字典的value就是参数的值
**形参只能有一个，并且必须写在所有参数的最后
"""
def function6(b, c, **a) :
    print('a=', a, type(a))
    print('b=', b)
    print('c=', c)

function6(b=1, d=2, c=3, e=4, f=5, a=6) 
"""
print:
a= {'d': 2, 'e': 4, 'f': 5, 'a': 6} <class 'dict'>
b= 1
c= 3
"""

print('***************参数的解包（拆包）********************')

# 参数的解包（拆包）
def function7(a, b, c) :        
    print('a=', a, 'b=', b, 'c=', c)

function7(0, 1, 2)

t = (3, 4, 5) # 创建一个元组

"""
传递实参时，可以在序列类型的参数前添加星号，
这样它会自动将序列中的元素依次作为参数传递。
序列中元素的个数必须和形参的个数一致。
"""
function7(*t)    

d = {'a':6, 'b':7, 'c':8} # 创建一个字典
# 通过**来对字典进行解包操作
function7(**d)
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

返回值

# 返回值：返回值就是函数执行以后返回的结果。
# 可以通过return来指定函数的返回值。
# 可以直接使用函数的返回值，也可以通过一个变量来接收函数的返回值。

def sum(*numbers) :
    # 定义一个变量，用来保存结果
    result = 0
    # 遍历元组，并将元组中的数进行累加。
    for n in numbers :
        result += n
    
    print(result)

sum(1, 2, 3) #print:6

# return后边跟什么值，函数就会返回什么值。
# return后边可以跟任意的对象，返回值可以是一个函数。
def function() :
    #return 100
    #return 'Hello'     
    #return [1, 2, 3] 
    #return {'k':'v'}
    
    def function1() :
        print('hello')

    return function1 # 返回值也可以是一个函数。

r = function() # 这个函数的执行结果就是它的返回值。
# print(fn())等价于print(r)
print(r) #print:100
r() #print:hello

print('*********************')

# 如果仅仅写一个return或者不写return，则相当于return None。 
def function1() :
    a = 10
    return 

print(function1()) #print:None

print('*************************')

# 在函数中，return后的代码都不会执行，return一旦执行函数自动结束。
def function2():
    print('hello')
    return
    print('abc')

r = function2()
print(r) #print:hello

print('*************************')

def function3() :
    
    for i in range(5):
        if i == 3 :
            return # return 结束函数；break 退出当前循环；continue 跳过当次循环。
        print(i)

    print('循环执行完毕！')


function3()

print('*************************')

def sum1(*numbers):
    # 定义一个变量，用来保存结果。
    result = 0
    # 遍历元组，并将元组中的数进行累加。
    for n in numbers :
        result += n
    return result

r = sum1(1, 2, 3)
print(r) #print:6
print(r + 1) #print:7

def function4() :
    return 1

# function4 和 function4()的区别
print(function4) # function4是函数对象，打印function4实际是在打印函数对象。#print:<function function4 at 0x018E1A50>
print(function4()) # function4()function4()实际上是在打印function4()函数的返回值1。#print:1
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

文档字符串

"""
help()是Python中的内置函数
通过help()函数可以查询python中的函数的用法
 语法：help(函数对象)
"""

#help(print) # 获取print()函数的使用说明。


def function(a, b, c) : 
    return 1

help(function)


"""
文档字符串。
在定义函数时，可以在函数内部编写文档字符串，文档字符串就是函数的说明。
当编写了文档字符串时，就可以通过help()函数来查看函数的说明。
文档字符串非常简单，其实直接在函数的第一行写一个字符串就是文档字符串
"""
def function1(a:int, b:bool, c:str='hello') -> int:
    '''
    这是一个文档字符串的示例

    函数的作用：。。。。。
    函数的参数：
        a，作用，类型，默认值。。。。。。
        b，作用，类型，默认值。。。。。。
        c，作用，类型，默认值。。。。。。
    '''
    return 10

help(function1)
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

作用域与命名空间

# 作用域（scope）。作用域指的是变量生效的区域
a = 1 # 全局变量

def function():
    b = 2 # a定义在了函数内部，所以他的作用域就是函数内部，函数外部无法访问。
    print('函数内部：','a =',a)
    print('函数内部：','b =',b)

function()    

print('函数外部：','a =',a)

"""
在Python中一共有两种作用域
    全局作用域
        全局作用域在程序执行时创建，在程序执行结束时销毁
        所有函数以外的区域都是全局作用域
        在全局作用域中定义的变量，都属于全局变量，全局变量可以在程序的任意位置被访问。
    
    函数作用域
        函数作用域在函数调用时创建，在调用结束时销毁
        函数每调用一次就会产生一个新的函数作用域
        在函数作用域中定义的变量，都是局部变量，它只能在函数内部被访问
    
    变量的查找
        当使用变量时，会优先在当前作用域中寻找该变量，如果有则使用，
        如果没有则继续去上一级作用域中寻找，如果有则使用，
        如果依然没有则继续去上一级作用域中寻找，以此类推
        直到找到全局作用域，依然没有找到，则会抛出异常
            NameError: name 'a' is not defined
"""
def function1() :
    a = 1
    def function2() :
        a = 2
        print('function2中:','a=', a)
    function2()

function1()    

a = 3

def function3() :
    #a = 4 # 在函数中为变量赋值时，默认都是为局部变量赋值
    # 如果希望在函数内部修改全局变量，则需要使用global关键字，来声明变量
    #global a # 声明在函数内部的变量a是全局变量，此时再去修改a时，就是在修改全局的a
    a = 5 # 修改全局变量
    print('函数内部：', 'a=', a)

function3()
print('函数外部：','a=', a)

print('*************命名空间***********************************')

# 命名空间（namespace）
# 命名空间指的是变量存储的位置，每一个变量都需要存储到指定的命名空间当中
# 每一个作用域都会有一个它对应的命名空间
# 全局命名空间，用来保存全局变量。函数命名空间用来保存函数中的变量
# 命名空间实际上就是一个字典，是一个专门用来存储变量的字典

# locals()用来获取当前作用域的命名空间

# 如果在全局作用域中调用locals()则获取全局命名空间，如果在函数作用域中调用locals()则获取函数命名空间，返回的是一个字典。
scope = locals() # 当前命名空间
print(type(scope))
print(scope)
print(a)

# print(scope['a'])

# 向scope中添加一个key-value
scope['c'] = 1000 # 向字典中添加key-value就相当于在全局中创建了一个变量（一般不建议这么做）
print(c)

def function4() :
    a = 10
    scope = locals() # 在函数内部调用locals()会获取到函数的命名空间
    # scope['b'] = 20 # 可以通过scope来操作函数的命名空间，但是也是不建议这么做

    # globals() 函数可以用来在任意位置获取全局命名空间
    global_scope = globals()
    # print(global_scope['a'])
    global_scope['a'] = 30
    print(scope)

function4()    
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

# 作用域（scope）。作用域指的是变量生效的区域
a = 1 # 全局变量

def function() :
    b = 2 # b定义在了函数内部，所以他的作用域是函数内部，函数外部无法访问。
    
    print('函数内部：', 'a =', a) 
    print('函数内部：', 'b =', b)

function()    

print('函数外部：', 'a =', a)

"""
Python中一共有两种作用域：全局作用域、函数作用域
    
    全局作用域：
        全局作用域在程序执行时创建，在程序执行结束时销毁。
        所有函数以外的区域都是全局作用域。
        在全局作用域中定义的变量，都属于全局变量；全局变量可以在程序的任意位置被访问。
    
    函数作用域：
        函数作用域在函数调用时创建，在调用结束时销毁。
        函数每调用一次就会产生一个新的函数作用域。
        在函数作用域中定义的变量，都是局部变量，它只能在函数内部被访问。
    
    
    变量的查找
        当使用变量时，会优先在当前作用域中寻找该变量，如果有则使用，
        如果没有则继续去上一级作用域中寻找，如果有则使用，
        如果依然没有则继续去上一级作用域中寻找，以此类推,
        直到找到全局作用域，依然没有找到，则会抛出异常:
        NameError: name 'a' is not defined
"""
def function1() :
    a = 1

    def function2() :
        a = 2
        print('function2中:','a=', a)
    
    function2()

function1()    


a = 3

def function3() :
    #a = 4 # 在函数中为变量赋值时，默认都是为局部变量赋值。
    # 如果在函数内部修改全局变量，则需要使用global关键字。
    # global a # 声明在函数内部的变量a是全局变量，此时再去修改a时，就是在修改全局的变量a
    a = 5 # 修改全局变量
    print('函数内部：', 'a=', a)

function3()
print('函数外部：','a=', a)
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

递归

"""
求10的阶乘（10!）
1! = 1
2! = 1*2 = 2
3! = 1*2*3 = 6
4! = 1*2*3*4 = 24

print(1*2*3*4*5*6*7*8*9*10)
"""

# 创建一个变量保存结果
n = 10
for i in range(1,10):
    n *= i

print(n)

# 创建一个函数，可以用来求任意数的阶乘。
def factorial(n) :
    '''
        该函数用来求任意数的阶乘

        参数：
            n 要求阶乘的数字
    '''

    # 创建一个变量，来保存结果
    result = n
    
    for i in range(1, n) :
        result *= i

    return result    

# 求5的阶乘    
print(factorial(5))

# 递归简单理解就是自己去引用自己！
# 递归式函数，在函数中自己调用自己！

# 无穷递归，如果这个函数被调用，程序的内存会溢出，效果类似于死循环
# def fn():
#     fn()
# fn()

# 递归是解决问题的一种方式，它和循环很像
#   它的整体思想是，将一个大问题分解为一个个的小问题，直到问题无法分解时，再去解决问题
# 递归式函数的两个要件
#   1.基线条件
#       问题可以被分解为的最小问题，当满足基线条件时，递归就不在执行了
#   2.递归条件
#       将问题继续分解的条件
# 递归和循环类似，基本是可以互相代替的，
#   循环编写起来比较容易，阅读起来稍难
#   递归编写起来难，但是方便阅读
# 10! = 10 * 9!
# 9! = 9 * 8!
# 8! = 8 * 7!
# ...
# 1! = 1

def factorial(n):
    '''
        该函数用来求任意数的阶乘

        参数：
            n 要求阶乘的数字
    '''
    # 基线条件 判断n是否为1，如果为1则此时不能再继续递归
    if n == 1 :
        # 1的阶乘就是1，直接返回1
        return 1

    # 递归条件    
    return n * factorial(n-1)

print(factorial(5))
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

练习一

创建一个函数，可以用来求任意数的阶乘。

def factorial(n) :
    '''
        该函数用来求任意数的阶乘

        参数：
            n 要求阶乘的数字
    '''

    # 创建一个变量，来保存结果
    result = n
    
    for i in range(1, n) :
        result *= i

    return result    

# 求5的阶乘    
print(factorial(5))

# 递归简单理解就是自己去引用自己！
# 递归式函数，在函数中自己调用自己！

# 无穷递归，如果这个函数被调用，程序的内存会溢出，效果类似于死循环
# def fn():
#     fn()
# fn()

# 递归是解决问题的一种方式，它和循环很像
#   它的整体思想是，将一个大问题分解为一个个的小问题，直到问题无法分解时，再去解决问题
# 递归式函数的两个要件
#   1.基线条件
#       问题可以被分解为的最小问题，当满足基线条件时，递归就不在执行了
#   2.递归条件
#       将问题继续分解的条件
# 递归和循环类似，基本是可以互相代替的，
#   循环编写起来比较容易，阅读起来稍难
#   递归编写起来难，但是方便阅读
# 10! = 10 * 9!
# 9! = 9 * 8!
# 8! = 8 * 7!
# ...
# 1! = 1

def factorial(n):
    '''
        该函数用来求任意数的阶乘

        参数：
            n 要求阶乘的数字
    '''
    # 基线条件 判断n是否为1，如果为1则此时不能再继续递归
    if n == 1 :
        # 1的阶乘就是1，直接返回1
        return 1

    # 递归条件    
    return n * factorial(n-1)

print(factorial(5))
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

练习二

创建一个函数，用来检查一个任意的字符串是否是回文字符串，如果是返回True，否则返回False。

# 回文字符串，字符串从前往后念和从后往前念是一样的。
# abcba
# abcdefgfedcba
# 先检查第一个字符和最后一个字符是否一致，如果不一致则不是回文字符串。
# 如果一致，则看剩余的部分是否是回文字符串。

# 检查 abcdefgfedcba 是不是回文
# 检查 bcdefgfedcb 是不是回文
# 检查 cdefgfedc 是不是回文
# 检查 defgfed 是不是回文
# 检查 efgfe 是不是回文
# 检查 fgf 是不是回文
# 检查 g 是不是回文

def hui_wen(s) :
    '''
        该函数用来检查指定的字符串是否是回文字符串，如果是返回True，否则返回False。

        参数：
            s：就是要检查的字符串。
    '''
    # 基线条件
    if len(s) < 2 :
        # 字符串的长度小于2，则字符串一定是回文
        return True

    elif s[0] != s[-1] :
        # 第一个字符和最后一个字符不相等，不是回文字符串。
        return False    
    
    # 递归条件    
    return hui_wen(s[1:-1])

print(hui_wen('abcdefgfedcba')) #print:True  

# 使用递归
def hui_wen1(s):
     '''
        该函数用来检查指定的字符串是否回文字符串，如果是返回True，否则返回False。

        参数：
            s：就是要检查的字符串。
     '''
     # 基线条件
     if len(s) < 2 :
         # 字符串的长度小于2，则字符串一定是回文。
         return True
     # 递归条件    
     return s[0] == s[-1] and hui_wen(s[1:-1])

print(hui_wen1('abcdefgfedcba')) #print:True
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

函数式编程

在Python中，函数是一等对象。
一等对象具有如下特点：
1、对象是在运行时创建的。
2、能赋值给变量或作为数据结构中的元素。
3、能作为参数传递。
4、能作为返回值返回。

高阶函数

高阶函数至少要符合以下两个特点中的一个。
1、接收一个或多个函数作为参数。
2、将函数作为返回值返回。

装饰器

模块

第三方模块的安装

在命令行窗口执行命令：
默认访问国外网站下载：pip install 模块名称
例如：pip install pandas
清华大学提供：pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 模块名称
例如：pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pandas

验证安装是否成功：import 模块名称
例如：import pandas

exercise problems

简单题

examination questions:
简述Python中函数参数的种类和定义方法。

solution:

函数参数的种类：
一、无参函数
二、有参函数
1、定长参数：
（1）位置参数
语法：
def func_name(arg1, arg2, arg3…):
函数体

在参数列表中，只定义了参数名字的参数都是位置参数。
（2）默认参数
在定义函数时给参数设置默认值，这样的参数称为默认参数。给参数添加默认值的方法是在定义函数时使用“=”给参数赋值，等号右侧即为参数的默认值。设置了默认值的参数，在调用时可以不给这个参数显式赋值，此时参数值就是它的默认值。如果在调用时给这个参数赋值，则默认值不生效。
2、不定长参数
（1）包裹位置参数
定义包裹位置参数是在参数名前添加一个“*”。在调用函数时，就可以传入多个数值，给包裹位置参数赋值和给普通位置赋值一样，参数值之间以“,”分隔，这些数值将统一被参数args以元组的方式接收。
（2）包裹关键字参数
包裹关键字参数与包裹位置参数一样都是不定长参数，只是包裹关键字参数接收的参数都是以关键字参数的形式传入的，也就是每个参数的形式都是“参数名=参数值”。当参数传入到函数中后，这些传入的参数会以字典的形式组织在一起，其中关键字参数的参数名就是字典中的键，参数值就是键对应的值。

examination questions:
简述在包中定义模块的方法以及注意事项。

solution:

为了更好地组织模块，通常会将多个功能相近或有关联的模块放在一个包中。包就是Python模块文件所在的目录，文件夹名就是包名。在使用包时，文件夹下必须存在一个__init__.py文件（文件内容可以为空），用于标识当前文件夹是一个包，如果缺少了这个文件，文件夹外的文件将无法导入文件中的模块。

编码题

examination questions:
创建max函数，返回从键盘输入的5个整数中的最大数，如下所示：
请输入第1个数：23
请输入第2个数：543
请输入第3个数：234
请输入第4个数：65
请输入第5个数：99
最大的数是：543

solution:

"""
无参方法
"""
"""
def max():
    
    max = 0

    for i in range(5):
        number = int(input('请输入第%d个数：'%(i+1)))
        if number > max:
            max = number

    return max

max_number = max()
print('最大的数是：', max_number)
"""

"""
有参方法
"""
def max(number_list):
    max = 0
    for i in range(0, len(number_list)):
        if number_list[i]>max:
            max = number_list[i]
    return max

number_list = []

for i in range(5):
    print('请输入第%d个数：'%(i+1), end='')
    number = input()
    number_list.append(int(number))

number_max = max(number_list)
print("最大的数是：", number_max)
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
35
36
37
38

examination questions:
定义函数接收年份和月份，返回对应月份有多少天。
1、闰年二月为29天，否则为28天（闰年就是二月有29天的年份，能被4整除但是不能被100整除的是闰年，能被400整除的也是闰年）。
2、四月、六月、九月、十一月为30天。
3、其余月份为31天。

solution:

def get_days_in_month(year, month):
    
    if month == 1 or month == 3 or month == 5 or month == 7 or month == 8 or month == 10 or month == 12:
        return 31

    elif month == 4 or month == 6 or month == 9 or month == 11:
        return 30 
    
    else:
        if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
            return 29
        
        else:
            return 28

year = int(input('请输入年份：'))
month = int(input('请输入月份：'))

days = get_days_in_month(year, month)

print(year, '年', month, '月', '有', days, '天。')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

examination questions:
编写函数接收一个时间（小时、分、秒），返回该时间的下一秒。
例如：分别输入的是10、20、59，表示10点20分59秒，下一秒就是10点21分0秒。

solution:

def get_next_second(hour, minute, second):
    
    hour = int(hour)
    minute = int(minute)
    second = int(second)

    second += 1
    second = second % 60
    
    if second == 0:
        minute += 1
    	minute = minute % 60
    
    if minute == 0:
        hour += 1
    
    hour = hour % 24
    
    return [hour, minute, second]

time = input('请输入时间：')
time = time.split(' ')
print('下一秒的时间是：', get_next_second(time[0], time[1], time[2]))
print('下一秒的时间是：%d点%d分%d秒'%(time_list[0], time_list[1], time_list[2]))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

异常

文件

文件打开

# open(file, mode='r', buffering=-1, encoding_=None, errors=None, newline=None, closefd=True, opener=None)
# 使用open函数打开一个文件。
# 参数：
#     file 要打开的文件的名字（路径）
# 返回值：
#   返回一个对象，这个对象就代表当前打开的文件。

# 创建一个变量，保存文件的名字。
# 如果目标文件和当前文件在同一级目录下，则直接使用文件名即可。
file_name = 'file/demo.txt'
print(file_name)

file_obj = open(file_name) # 打开 file_name 对应的文件。
print(file_obj)

# 在windows系统使用路径时，可以使用/来代替 \。或者可以使用 \\ 来代替 \。或者也可以使用原始字符串。
#file_name = 'hello\\demo.txt'
#file_name = r'hello\demo.txt'

# 表示路径，可以使用..来返回上一级目录。
#file_name = '../hello/demo.txt'

# 绝对路径应该从磁盘的根目录开始书写。
#file_name = r'E:\source_code\python\language\00000\00006_文件\code\file\hello.txt'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

文件关闭

# 打开文件
file_name = 'file/demo.txt'

# 调用open()来打开文件
file_obj = open(file_name)
print(file_obj)
print(type(file_obj))

# 当获取了文件对象以后，所有的对文件的操作都应该通过对象来进行。
# 读取文件中的内容
# read()方法，用来读取文件中的内容，它会将内容全部保存为一个字符串返回。
content = file_obj.read()
print(content)

print('*************************')

# 关闭文件
# 调用close()方法关闭文件。
file_obj.close()

#file_obj.read()

# with ... as 语句
# with open(file_name) as file_obj :
#     在with语句中可以直接使用file_obj来做文件操作
#     此时这个文件只能在with中使用，一旦with结束则文件会自动close()
#     print(file_obj.read())


file_name = 'file/demo.txt'

try:
    with open(file_name) as file_obj :
        print(file_obj.read())

except FileNotFoundError:
    print(f'{file_name} 文件不存在。')
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
35
36
37

文件读取

file_name = 'file/demo1.txt'

try:
    # 调用open()来打开一个文件，可以将文件分成两种类型：
    # 1、纯文本文件（使用utf-8等编码编写的文本文件）
    # 2、二进制文件（图片、mp3、ppt等文件）
    # open()打开文件时，默认是以文本文件的形式打开的，但是open()默认的编码为None。所以处理文本文件时，必须要指定文件的编码。
    with open(file_name, encoding='utf-8') as file_obj:
        # 通过 read() 来读取文件中的内容
        #content = file_obj.read() #read()等价read(-1),参数-1表示读取所有。
        #print(content)

        # 如果直接调用read()，会将文本文件的所有内容全部读取出来。
        #   如果要读取的文件较大，会一次性将文件的内容加载到内存中，容易导致内存泄漏。
        #   所以对于较大的文件，不要直接调用read()。
        
        # help(file_obj.read) #read()帮助信息。
        
        # read()可以接收一个size作为参数，该参数用来指定要读取的字符的数量。
        #   默认值为-1，它会读取文件中的所有字符。
        #   可以为size指定一个值，这样read()会读取指定数量的字符，
        #       每一次读取都是从上次读取到位置开始读取的
        #       如果字符的数量小于size，则会读取剩余所有的
        #       如果已经读取到了文件的最后，则会返回''空串。
        
        #content = file_obj.read(-1)
        
        content = file_obj.read(6)
        print(content)
        print(len(content))
        content = file_obj.read(6)
        print(content)
        print(len(content))
        content = file_obj.read(6)
        print(content)
        print(len(content))
        content = file_obj.read(6)
        print(content)
        print(len(content))

except FileNotFoundError :
    print(f'{file_name} 这个文件不存在！')

print('*****************')

# 读取大文件的方式
file_name = 'file/demo.txt'

try:
    with open(file_name, encoding='utf-8') as file_obj:
        # 定义一个变量，来保存文件的内容
        file_content = ''
        # 定义一个变量，来指定每次读取的大小
        chunk = 100
        
        # 创建一个循环来读取文件内容
        while True:
            # 读取chunk大小的内容
            content = file_obj.read(chunk)

            # 检查是否读取到了内容
            if not content:
                # 内容读取完毕，退出循环
                break

            # 输出内容
            #print(content, end='')
            file_content += content

except FileNotFoundError :
    print(f'{file_name} 这个文件不存在！')

print(file_content)
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

import pprint
import os

file_name = 'file/demo.txt'

try:

    with open(file_name, encoding='utf-8') as file_obj:
        # readline() 该方法可以用来读取一行内容
        print(file_obj.readline(), end='')
        print(file_obj.readline())
        print(file_obj.readline())

        print('***********')

        # readlines() 该方法用于一行一行的读取内容，它会一次性将读取到的内容封装到一个列表中返回。
        #r = file_obj.readlines()       
        #pprint.pprint(r[0])
        #pprint.pprint(r[1])
        #pprint.pprint(r[2])

        for f in file_obj:
            print(f)

except FileNotFoundError:
    print(f'{file_name} 这个文件不存在！')
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

文件写入

file_name = 'file/demo2.txt'

# 使用open()打开文件时必须要指定打开文件所要做的操作（读、写、追加）
# 如果不指定操作类型，则默认是读取文件，而读取文件时是不能向文件中写入的
#   r 表示只读的

#   w 表示是可写的，使用w来写入文件时，如果文件不存在会创建文件，如果文件存在则会截断文件。
#       截断文件指删除原来文件中的所有内容
#   a 表示追加内容，如果文件不存在会创建文件，如果文件存在则会向文件中追加内容

#   x 用来新建文件，如果文件不存在则创建，存在则报错。
#   + 为操作符增加功能

#   r+ 即可读又可写，文件不存在会报错
#   w+
#   a+

# with open(file_name , 'w' , encoding='utf-8') as file_obj:
# with open(file_name , 'r+' , encoding='utf-8') as file_obj:

with open(file_name, 'a', encoding='utf-8') as file_obj:
    
    r = file_obj.write('今天天气真不错。')
    print('写入的字符个数：', r) 
    # write()向文件中写入内容，
    # 如果操作的是一个文本文件的话，则write()需要传递一个字符串作为参数
    # 该方法会分多次向文件中写入内容
    # 写入完成以后，该方法会返回写入的字符的个数。
    file_obj.write('aaa\n')
    file_obj.write('bbb\n')
    file_obj.write('ccc\n')
    
    r = file_obj.write(str(123)+'123123\n')
    print('写入的字符个数：', r)     
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

文件

file_name = 'file/1.jpg'

# 读取模式
# t 读取文本文件（默认值）
# b 读取二进制文件

with open(file_name, 'rb') as file_obj:
    # 读取文本文件时，size是以字符为单位的
    # 读取二进制文件时，size是以字节为单位
    #print(file_obj.read(100))

    # 将读取到的内容写出来
    # 定义一个新的文件
    new_file_name = 'file/2.jpg'

    with open(new_file_name, 'wb') as new_file_obj:

        # 定义每次读取的大小
        chunk = 1024 * 100

        while True :
            # 从已有的对象中读取数据
            content = file_obj.read(chunk)

            # 内容读取完毕，终止循环
            if not content :
                break

            # 将读取到的数据写入到新对象中
            new_file_obj.write(content)
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

案例

将九九乘法表写入文件中。

'''
#方法一
with open('file/3.txt', mode='w', encoding='utf-8') as file_object:
	for i in range(1, 10):
		for j in range(1, 10):
			if i>=j:
				#print(str(i) + '*' + str(j) + '=' + str(i*j) + '\t', end='')
				string = str(j) + '*' + str(i) + '=' + str(i*j) + '\t'
				print(string, end='')

				file_object.write(string)

		file_object.write('\n')
		print()
'''


'''
#方法二：效率高于方法一
with open('file/3.txt', mode='w', encoding='utf-8') as file_object:
	for i in range(1, 10):
		for j in range(1, 10):
			
			
			#print(str(i) + '*' + str(j) + '=' + str(i*j) + '\t', end='')
			string = str(j) + '*' + str(i) + '=' + str(i*j) + '\t'
			print(string, end='')

			file_object.write(string)

			if i<=j:
				break

		file_object.write('\n')
		print()
'''


'''
# 方法三
with open('file/3.txt', mode='w', encoding='utf-8') as file_object:

    for i in range(1, 10):
        
        # content=[]
        for j in range(1, 10):

            string = '%d * %d = %d  ' % (j, i, (j * i))

            if j > i :
                break
            elif j == i:
                print(string)
            else:
                print('%d * %d'%(j, i), '= %d'%(j*i) + '\t', end='')

            file_object.write(string)
            
		file_object.write('\n')
'''


# 方法四
with open('file/3.txt', mode='w', encoding='utf-8') as file_object:

    for i in range(1, 10):

        for j in range(1, i+1):

        	#string = '{}x{}={}\t'.format(i, j, i*j)
            string = '{}x{}={}\t'.format(j, i, i*j)
            print(string, end='')
            file_object.write(string)
			
			if i<=j:
				break
				
        print()
        file_object.write('\n')
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

exercise problems

编码题

examination questions:
（1）现有一份“邀请函.txt”的空白文件，请在同级目录下编写一段代码，写入内容“诚挚邀请您来参加本次宴会”。
（2）在第（1）题的基础上，添加问候语和发件人“best regards 李雷”，文件内容是：
橙子邀请您来参加本次宴会
best regards
李雷
（3）在第（2）题的基础上，将这封邮件发送给“丁一”“王美丽”“韩美美”三位朋友，在邮件内容开头处添加收件人名字，并且生成相应名字的邮件。例如丁一的邮件内容应该为：
丁一：
橙子邀请您来参加本次宴会
best regards
李雷
（4）在第（3）题的基础上，假设邀请函现在的目录是“D:/test/邀请函.txt”，需要将相应的邀请函邮件放入“D:/text/”路径下以各位收件人名字命名的文件夹中。例如，“丁一邀请函.txt”文件应该放在“D:/test/丁一/丁一邀请函.txt”路径下。

solution:
（1）

with open('file/邀请函.txt', mode='w', encoding='utf-8') as file_object:
	file_object.write('诚挚邀请您来参加本次宴会')
1
2

（2）

with open('file/邀请函.txt', mode='a', encoding='utf-8') as file_object:
	file_object.write('\n')
	file_object.write('best regards\n')
	file_object.write('李雷')
1
2
3
4

（3）

names = ['丁一', '王美丽', '韩梅梅']

with open('file/邀请函.txt', mode='r', encoding='utf-8') as file_object_read:
	content = file_object_read.read()
	
	for name in names:
	
		with open('file/%s邀请函.txt'%name, mode='w', encoding='utf-8') as file_object_write:
			
			file_object_write.write('%s:\n'%name)
			file_object_write.write(content)
1
2
3
4
5
6
7
8
9
10
11

（4）

import os
import shutil

path = 'file/'

names = ['丁一', '王美丽', '韩梅梅']

for name in names:
    
    if not os.path.exists(path+'%s/'%name):
        os.mkdir(path + '%s/'%name)

    shutil.move(path+'%s邀请函.txt'%name, path + '%s/%s邀请函.txt'%(name, name))
1
2
3
4
5
6
7
8
9
10
11
12
13

面向对象

# 对象（Object）

## 什么是对象？
    - 对象是内存中专门用来存储数据的一块区域。
    - 对象中可以存放各种数据（比如：数字、布尔值、代码）
    - 对象由三部分组成：
        1.对象的标识（id）
        2.对象的类型（type）
        3.对象的值（value）

## 面向对象（oop）
    - Python是一门面向对象的编程语言
    - 所谓的面向对象的语言，简单理解就是语言中的所有操作都是通过对象来进行的
    
    - 面向过程编程语言
        - 面向过程指将我们的程序的逻辑分解为一个一个的步骤，通过对每个步骤的抽象，来完成程序。
        - 面向过程的编程思想将一个功能分解为一个一个小的步骤，通过完成一个一个的小的步骤来完成一个程序。
        - 但是这种方式编写代码的往往只适用于一个功能，
            如果要在实现别的功能，即使功能相差极小，也往往要重新编写代码，
            所以它可复用性比较低，并且难于维护。 

    - 面向对象的编程语言
        - 面向对象的编程语言，关注的是对象，而不关注过程 
        - 对于面向对象的语言来说，一切都是对象。       

        - 面向对象的编程思想，将所有的功能统一保存到对应的对象中。
            要使用某个功能，直接找到对应的对象即可。

## 类(class) 
    - 我们目前所学习的对象都是Python内置的对象。
    - 但是内置对象并不能满足所有的需求，所以我们在开发中经常需要自定义一些对象。
    - 类，简单理解它就相当于一个图纸。在程序中我们需要根据类来创建对象
    - 类就是对象的图纸！
    - 我们也称对象是类的实例（instance）
    - 如果多个对象是通过一个类创建的，我们称这些对象是一类对象
    - 比如：int() float() bool() str() list() dict() ...这些都是类
    - a = int(10) # 创建一个int类的实例 等价于 a = 10
    - 我们自定义的类需要使用大写字母开头，使用大驼峰命名法（帕斯卡命名法）来对类命名。

    - 类也是一个对象！
    - 类就是一个用来创建对象的对象！
    - 类是type类型的对象，定义类实际上就是定义了一个type类型的对象。
    
## 使用类创建对象的流程（参考picture_00000.jpg）
    1.创建一个变量
    2.在内存中创建一个新对象
    3.将对象的id赋值给变量

## 类的定义（picture_00001.jpg）
    - 类和对象都是对现实生活中的事物或程序中的内容的抽象
    - 实际上所有的事物都由两部分构成：
        1.数据（属性）
        2.行为（方法）

    - 在类的代码块中，我们可以定义变量和函数，
        变量会成为该类实例的公共属性，所有的该类实例都可以通过 对象.属性名 的形式访问 
        函数会成为该类实例的公共方法，所有该类实例都可以通过 对象.方法名() 的形式调用方法

    - 注意：
        方法调用时，第一个参数由解析器自动传递，所以定义方法时，至少要定义一个形参！ 

    - 实例为什么能访问到类中的属性和方法
        类中定义的属性和方法都是公共的，任何该类实例都可以访问

        - 属性和方法查找的流程
            当我们调用一个对象的属性时，解析器会先在当前对象中寻找是否含有该属性，
                如果有，则直接返回当前的对象的属性值，
                如果没有，则去当前对象的类对象中去寻找，如果有则返回类对象的属性值，
                如果类对象中依然没有，则报错！

        - 类对象和实例对象中都可以保存属性（方法）
            - 如果这个属性（方法）是所有的实例共享的，则应该将其保存到类对象中
            - 如果这个属性（方法）是某个实例独有，则应该保存到实例对象中     
            
        - 一般情况下，属性保存到实例对象中
            而方法需要保存到类对象中    


## 创建对象的流程
    p1 = Person()的运行流程
        1.创建一个变量
        2.在内存中创建一个新对象
        3.__init__(self)方法执行
        4.将对象的id赋值给变量

## 类的基本结构   
    class 类名([父类]) :

        公共的属性... 

        # 对象的初始化方法
        def __init__(self,...):
            ...

        # 其他的方法    
        def method_1(self,...):
            ...

        def method_2(self,...):
            ...

        ...
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

类、对象

a = int(10) # 创建一个int类的实例
b = str('hello') # 创建一个str类的实例

print(a, type(a))
print(b, type(b))


# 定义一个简单的类
# 使用class关键字来定义类，语法和函数很像！
# class 类名([父类]):
#   代码块
class MyClass():
    pass

print(MyClass) # print:<class '__main__.MyClass'>

# 使用MyClass创建一个对象
# 使用类来创建对象，就像调用一个函数一样
mc = MyClass() # mc就是通过MyClass创建的对象，mc是MyClass的实例
mc_1 = MyClass()
mc_2 = MyClass()
mc_3 = MyClass()
# mc mc_1 mc_2 mc_3都是MyClass的实例，他们都是一类对象
print(mc) #print:<__main__.MyClass object at 0x01D0B310>
print(type(mc)) #print:<class '__main__.MyClass'>


# isinstance()：用来检查一个对象是否是一个类的实例
result = isinstance(mc_1, MyClass)
print('result =', result) #print:result = True
result = isinstance(mc_1, str)
print('result =', result) #print:result = False

print(id(MyClass), type(MyClass)) #print:21784464 <class 'type'>

# 现在我们通过MyClass这个类创建的对象都是一个空对象
# 也就是对象中实际上什么都没有，就相当于是一个空的盒子
# 可以向对象中添加变量，对象中的变量称为属性
# 语法：对象.属性名 = 属性值
mc.name = '宋江'
mc_1.name = '卢俊义'

print(mc.name) #print:宋江
print(mc_1.name) #print:卢俊义
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
35
36
37
38
39
40
41
42
43
44

定义类

# 定义一个表示人的类
class Person :
    # 在类的代码块中，我们可以定义变量和函数
    # 在类中我们所定义的变量，将会成为所有的实例的公共属性
    # 所有实例都可以访问这些变量
    name = '潘金莲' # 公共属性，所有实例都可以访问

    # 在类中也可以定义函数，类中的定义的函数，我们称为方法
    # 这些方法可以通过该类的所有实例来访问
    
    def say_hello(self) :
        # 方法每次被调用时，解析器都会自动传递第一个实参
        # 第一个参数，就是调用方法的对象本身，
        #   如果是p1调的，则第一个参数就是p1对象
        #   如果是p2调的，则第一个参数就是p2对象
        # 一般我们都会将这个参数命名为self

        # say_hello()这个方法，可以显示如下格式的数据：
        #   你好！我是 xxx
        #   在方法中不能直接访问类中的属性
        print('你好！我是 %s' %self.name)

# 创建Person的实例
p = Person()
p1 = Person()

print(p1.name)
# 调用方法，对象.方法名()
# 方法调用和函数调用的区别
# 如果是函数调用，则调用时传几个参数，就会有几个实参
# 但是如果是方法调用，默认传递一个参数，所以方法中至少要定义一个形参
p.say_hello()
p1.say_hello()

print('********************')

# 修改p的name属性
p.name = '吴用'
p1.name = '公孙胜'

p.say_hello() #print:你好！我是 吴用
p1.say_hello() #print:你好！我是 公孙胜

print(p.name) #print:吴用
print(p1.name) #print:公孙胜

del p1.name # 删除p2的name属性

print(p.name) #print:吴用
print(p1.name) 
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

对象的初始化

class Person :
    
    # 在类中可以定义一些特殊方法
    # 特殊方法都是以__开头，__结尾的方法
    # 特殊方法不需要我们自己调用，不要尝试去调用特殊方法
    # 特殊方法将会在特殊的时刻自动调用
    # 
    # 特殊方法：
    #   1.特殊方法什么时候调用
    #   2.特殊方法有什么作用
    # 
    # 创建对象的流程
    # p = Person()的运行流程
    #   1.创建一个变量p
    #   2.在内存中创建一个新对象
    #   3.__init__(self)方法执行
    #   4.将对象的id赋值给变量

    # init会在对象创建以后离开执行
    # init可以用来向新创建的对象中初始化属性
    # 调用类创建对象时，类后边的所有参数都会依次传递到init()中
    def __init__(self, name):
        # print(self)
        # 通过self向新建的对象中初始化属性
        self.name = name

    def say_hello(self):
        print('大家好，我是%s'%self.name)


# 目前来讲，对于Person类来说name是必须的，并且每一个对象中的name属性基本上都是不同
# 而我们现在是将name属性在定义为对象以后，手动添加到对象中，这种方式很容易出现错误
# 我们希望，在创建对象时，必须设置name属性，如果不设置对象将无法创建
#   并且属性的创建应该是自动完成的，而不是在创建对象以后手动完成
#p = Person()
# 手动向对象添加name属性
#p.name = '宋江'

#p1 = Person()
#p1.name = '卢俊义'

#p2 = Person()
#p2.name = '公孙胜'

#p3.say_hello()


p = Person('宋江')
p1 = Person('卢俊义')
p2 = Person('吴用')
p3 = Person('公孙胜')
# p.__init__() # 不要调用

print(p.name) #print:宋江
print(p1.name) #print:卢俊义
print(p2.name) #print:吴用
print(p3.name) #print:公孙胜

p3.say_hello() #print:大家好，我是公孙胜
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

class Person:

    def __init__(self, name, age, gender, height):
        self.name = name
        self.age = age
        self.gender = gender
        self.height = height

    def eat(self):
        print('吃饭')

    def sleep(self):  
        print('睡觉')

    def run(self):
        print('%s快乐的奔跑。'%self.name)     


person = Person('宋江', 40, 'male', 180)
print(person.name , person.age , person.gender , person.height)
person.eat()
person.sleep()
person.run()

person.name = '卢俊义'
person.age = -10
print(person.name)
print(person.age)    
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

封装

# 封装是面向对象的三大特性之一
# 封装指的是隐藏对象中一些不希望被外部所访问到的属性或方法
# 如何隐藏一个对象中的属性？
#   - 将对象的属性名，修改为一个外部不知道的名字
# 如何获取（修改）对象中的属性？
#   - 需要提供一个getter和setter方法使外部可以访问到属性
#   - getter 获取对象中的指定属性（get_属性名）
#   - setter 用来设置对象的指定属性（set_属性名）
# 使用封装，确实增加了类的定义的复杂程度，但是它也确保了数据的安全性
#   1.隐藏了属性名，使调用者无法随意的修改对象中的属性
#   2.增加了getter和setter方法，很好的控制了属性是否是只读的
#       如果希望属性是只读的，则可以直接去掉setter方法
#       如果希望属性不能被外部访问，则可以直接去掉getter方法
#   3.使用setter方法设置属性，可以增加数据的验证，确保数据的值是正确的
#   4.使用getter方法获取属性，使用setter方法设置属性
#       可以在读取属性和修改属性的同时做一些其他的处理

class Person:

    def __init__(self, name, age) :
        self.hidden_name = name
        self.hidden_age = age

    def say_hello(self):
        print('大家好，我是%s。今年%d岁。'%(self.hidden_name, self.hidden_age)) 

    def get_name(self):
        '''
            get_name()用来获取对象的name属性
        '''    
        # print('用户读取了属性')
        return self.hidden_name

    def set_name(self, name):
        # print('用户修改了属性')
        self.hidden_name = name

    def get_age(self):
        return self.hidden_age

    def set_age(self, age):
        if age > 0 :
            self.hidden_age = age    

person = Person('宋江', 50)

person.say_hello()

# 调用setter来修改name属性 
person.set_name('卢俊义')
person.set_age(-10)

person.say_hello()

print(person.get_age())
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

class Rectangle:
    '''
        表示矩形的类
    '''
    def __init__(self, width, height) :
        self.hidden_width = width
        self.hidden_height = height

    def get_width(self) :
        return self.hidden_width

    def get_height(self) :
        return self.hidden_height   

    def set_width(self, width) :
        self.hidden_width = width 

    def set_height(self, height) :
        self.hidden_height = height 

    def get_area(self) :
        return self.hidden_width * self.hidden_height        

r = Rectangle(4, 2) 
print(r.get_area()) #print:8

r.set_width(5)
r.set_height(3)
print(r.get_area()) #print:15
     
# 可以为对象的属性使用双下划线开头。__xxx
# 双下划线开头的属性，是对象的隐藏属性，隐藏属性只能在类的内部访问，无法通过对象访问。
# 其实隐藏属性只不过是Python自动为属性改了一个名字。
# 实际上是将名字修改为了，_类名__属性名 比如 __name -> _Person__name
class Person :
    def __init__(self, name) :
        self.__name = name

    def get_name(self):
        return self.__name

    def set_name(self, name):
        self.__name = name        

person = Person('宋江')
print(person.get_name()) #print:宋江

#print(person.__name) #error code。__开头的属性是隐藏属性，无法通过对象访问
#person.__name = '卢俊义' #error code

print(person._Person__name) #print:宋江
person._Person__name = '卢俊义'
print(person.get_name()) #print:卢俊义

print('*******************')

# 使用__开头的属性，实际上依然可以在外部访问，所以这种方式我们一般不用
#   一般我们会将一些私有属性（不希望被外部访问的属性）以_开头
#   一般情况下，使用_开头的属性都是私有属性，没有特殊需要不要修改私有属性
class Person1 :
    def __init__(self, name):
        self._name = name

    def get_name(self):
        return self._name

    def set_name(self, name):
        self._name = name   

person = Person1('吴用')
#print(person._name) #error code
print(person.get_name()) #print:吴用
person._name = '潘金莲'
print(person.get_name()) #print:潘金莲
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

class Person :
    def __init__(self, name, age):
        self._name = name
        self._age = age

    # property装饰器，用来将一个get方法，转换为对象的属性。
    # 添加为property装饰器以后，我们就可以像调用属性一样使用get方法。
    # 使用property装饰的方法，必须和属性名是一样的。
    @property    
    def name(self) :
        print('get方法执行了。')
        return self._name

    # setter方法的装饰器：@属性名.setter
    @name.setter    
    def name(self, name):
        print('setter方法调用了')
        self._name = name        

    @property
    def age(self):
        return self._age

    @age.setter    
    def age(self, age):
        self._age = age   

person = Person('宋江', 50)
print(person.name, person.age)

person.name = '卢俊义'
person.age = 51
print(person.name, person.age)
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

继承

# 继承

# 定义一个类 Animal（动物）
#   这个类中需要两个方法：run() sleep() 
class Animal:
    def run(self):
        print('动物会跑。')

    def sleep(self):
        print('动物睡觉。')

    # def bark(self):
    #     print('动物嚎叫')   

#定义一个类 Dog（狗）
#  这个类中需要三个方法：run() sleep() bark()
#       - 继承是面向对象三大特性之一
#       - 通过继承我们可以使一个类获取到其他类中的属性和方法
#       - 在定义类时，可以在类名后的括号中指定当前类的父类（超类、基类、super）
#           子类（衍生类）可以直接继承父类中的所有的属性和方法
#           
#  通过继承可以直接让子类获取到父类的方法或属性，避免编写重复性的代码，并且也符合OCP原则。
#OCP原则[开闭原则]，英文缩写OCP,全称Open Closed Principle。
class Dog(Animal) :
    def bark(self) :
        print('汪汪汪') 

    def run(self):
        print('狗跑。')    

class Hashiqi(Dog):
    def fan_sha(self):
        print('我是一只哈士奇')        

dog = Dog()
h = Hashiqi()

dog.run()
dog.sleep()
dog.bark()

r = isinstance(dog, Dog)
print(r) #print:True
r = isinstance(dog, Animal)
print(r) #print:True

# 在创建类时，如果省略了父类，则默认父类为object，object是所有类的父类，所有类都继承自object。
class Person(object):
    pass

# issubclass() 检查一个类是否是另一个类的子类
print(issubclass(Animal, Dog)) #print:False
print(issubclass(Animal, object)) #print:True
print(issubclass(Person, object)) #print:True

# isinstance()用来检查一个对象是否是一个类的实例
# 如果这个类是这个对象的父类，也会返回True
# 所有的对象都是object的实例
print(isinstance(print, object)) #print:True
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

class Animal:
    def sleep(self):
        print('动物睡觉。')

    def run(self):
        print('动物会跑。')   

class Dog(Animal):
    def bark(self):
        print('汪汪汪') 

    def run(self):
        print('狗跑')    


# 如果在子类中如果有和父类同名的方法，则通过子类实例去调用方法时，
# 会调用子类的方法而不是父类的方法，这个特点称为方法的重写（覆盖，override）
 
#创建Dog类的实例
dog = Dog()
dog.run()

# 当我们调用一个对象的方法时，
#   会优先去当前对象中寻找是否具有该方法，如果有则直接调用
#   如果没有，则去当前对象的父类中寻找，如果父类中有则直接调用父类中的方法，
#   如果没有，则去父类的父类中寻找，以此类推，直到找到object，如果依然没有找到，则报错
class One(object):
    def test(self):
        print('one')

class Two(One):
    def test(self):
        print('two')

class Three(Two):
    def test(self):
        print('three')   

# 创建一个Three的实例
three = Three()
three.test()
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
35
36
37
38
39
40
41

class Animal:

    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter    
    def name(self, name):
        self._name = name

    def run(self):
        print('动物会跑。')

    def sleep(self):
        print('动物睡觉。')

# 父类中的所有方法都会被子类继承，包括特殊方法，也可以重写特殊方法
class Dog(Animal):

    def __init__(self, name, age):
        # 希望可以直接调用父类的__init__来初始化父类中定义的属性
        # super() 可以用来获取当前类的父类，
        #   并且通过super()返回对象调用父类方法时，不需要传递self
        super().__init__(name)
        self._age = age

    @property
    def age(self):
        return self._age

    @age.setter    
    def age(self, age):
        self._age = name 

    def run(self):
        print('狗跑。')  

    def bark(self):
        print('汪汪汪。')        

dog = Dog('杨戬', 3) 

print(dog.name)       
print(dog.age)       
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
35
36
37
38
39
40
41
42
43
44
45
46
47

多继承

class One(object):
    def test(self):
        print('one')

class Two(object):
    def test(self):
        print('类Two中的test()方法。')

    def test1(self):
        print('two') 

# 在Python中是支持多重继承的，也就是我们可以为一个类同时指定多个父类
#   可以在类名的()后边添加多个类，来实现多重继承
#   多重继承，会使子类同时拥有多个父类，并且会获取到所有父类中的方法
# 如果多个父类中有同名的方法，则会先在第一个父类中寻找，然后找第二个，然后找第三个。。。
#   前边父类的方法会覆盖后边父类的方法
class Three(One, Two):
    pass

# 类名.__bases__ 这个属性可以用来获取当前类的所有父类    
print(Three.__bases__) #print:(<class '__main__.One'>, <class '__main__.Two'>)
print(Two.__bases__) #print:(<class 'object'>,)
print(One.__bases__) #print:(<class 'object'>,)

three = Three()
three.test() #print:one
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

多态

class A:
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name
        
    @name.setter
    def name(self, name):
        self._name = name   

class B:
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name
        
    @name.setter
    def name(self, name):
        self._name = name  

    def __len__(self):
        return 10

class C:
    pass

a = A('宋江')
b = B('卢俊义')
c = C()

# 定义一个函数
# 对于say_hello()这个函数来说，只要对象中含有name属性，它就可以作为参数传递
#   这个函数并不会考虑对象的类型，只要有name属性即可
def say_hello(object):
    print('你好%s'%object.name)

# 在say_hello_2中我们做了一个类型检查，也就是只有obj是A类型的对象时，才可以正常使用，
#   其他类型的对象都无法使用该函数，这个函数就违反了多态
# 违反了多态的函数，只适用于一种类型的对象，无法处理其他类型对象，这样导致函数的适应性非常的差
# 注意，像isinstance()这种函数，在开发中一般是不会使用的！
def say_hello_1(object):
    # 做类型检查
    if isinstance(object, A):
        print('你好%s'%object.name)    
    else:
        print('不是实例对象。')

say_hello(a) #print:你好宋江
say_hello(b) #print:你好卢俊义

print("****************")

say_hello_1(b)

# len()
# 之所以一个对象能通过len()来获取长度，是因为对象中具有一个特殊方法__len__
# 换句话说，只要对象中具有__len__特殊方法，就可以通过len()来获取它的长度
list = [1,2,3]
string = 'hello'

print(len(list)) #print:3
print(len(string)) #print:5

print(len(b)) #print:10
# print(len(c)) #error code
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

类中的属性和方法

class A(object):

    # 类属性
    # 实例属性
    # 类方法
    # 实例方法
    # 静态方法

    # 类属性，直接在类中定义的属性是类属性
    #   类属性可以通过类或类的实例访问到
    #   但是类属性只能通过类对象来修改，无法通过实例对象修改
    count = 0

    def __init__(self):
        # 实例属性，通过实例对象添加的属性属于实例属性
        #   实例属性只能通过实例对象来访问和修改，类对象无法访问修改
        self.name = '宋江'


    # 实例方法
    #   在类中定义，以self为第一个参数的方法都是实例方法
    #   实例方法在调用时，Python会将调用对象作为self传入  
    #   实例方法可以通过实例和类去调用
    #       当通过实例调用时，会自动将当前调用对象作为self传入
    #       当通过类调用时，不会自动传递self，此时我们必须手动传递self
    def test(self):
        print('这是test方法。' , self)    


    # 类方法    
    # 在类内部使用 @classmethod 来修饰的方法属于类方法。
    # 类方法的第一个参数是cls，也会被自动传递，cls就是当前的类对象。
    #   类方法和实例方法的区别，实例方法的第一个参数是self，而类方法的第一个参数是cls。
    #   类方法可以通过类去调用，也可以通过实例调用，没有区别。
    @classmethod
    def test_2(cls):
        print('这是test_2方法，他是一个类方法。', cls)
        print(cls.count)

    # 静态方法
    # 在类中使用 @staticmethod 来修饰的方法属于静态方法  
    # 静态方法不需要指定任何的默认参数，静态方法可以通过类和实例去调用  
    # 静态方法，基本上是一个和当前类无关的方法，它只是一个保存到当前类中的函数
    # 静态方法一般都是一些工具方法，和当前类无关
    @staticmethod
    def test_3():
        print('test_3执行了。')


a = A()
# 实例属性，通过实例对象添加的属性属于实例属性
a.count = 10
A.count = 100
print('A ,', A.count) #print:A , 100
print('a ,', a.count) #print:a , 10

#print('A ,', A.name) 
print('a ,', a.name) #print:a , 宋江

# a.test() 等价于 A.test(a)
a.test() #print:这是test方法。 <__main__.A object at 0x01B82730>
A.test(a) #print:这是test方法。 <__main__.A object at 0x01B82730>

# A.test_2() 等价于 a.test_2()
A.test_2()
a.test_2()

A.test_3() #print:test_3执行了。
a.test_3() #print:test_3执行了。
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

垃圾回收

class One:

    def __init__(self):
        self.name = ''

    # del是一个特殊方法，它会在对象被垃圾回收前调用
    def __del__(self):
        print('对象被回收了', self)

one = One()
print(one.name)

#one = None # 将对象one设置为了None，此时没有任何的变量对one对象进行引用，它就变成了垃圾。

two = one # 又使用一个变量two，来引用对象one对应的对象
#one = None
#two = None

del one
del two

input('回车键退出...')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

特殊方法

# 特殊方法，也称为魔术方法
# 特殊方法都是使用__开头和结尾的
# 特殊方法一般不需要我们手动调用，需要在一些特殊情况下自动执行

class Person(object):

    def __init__(self, name, age):
        self.name = name
        self.age = age

    # __str__（）这个特殊方法会在尝试将对象转换为字符串的时候调用
    # 它的作用可以用来指定对象转换为字符串的结果 （print函数）  
    def __str__(self):
        return 'Person [name=%s , age=%d]'%(self.name, self.age)        

    # __repr__()这个特殊方法会在对当前对象使用repr()函数时调用
    # 它的作用是指定对象在‘交互模式’中直接输出的效果。    
    def __repr__(self):
        return 'Hello'        

    # object.__add__(self, other)
    # object.__sub__(self, other)
    # object.__mul__(self, other)
    # object.__matmul__(self, other)
    # object.__truediv__(self, other)
    # object.__floordiv__(self, other)
    # object.__mod__(self, other)
    # object.__divmod__(self, other)
    # object.__pow__(self, other[, modulo])
    # object.__lshift__(self, other)
    # object.__rshift__(self, other)
    # object.__and__(self, other)
    # object.__xor__(self, other)
    # object.__or__(self, other)

    # object.__lt__(self, other) 小于 <
    # object.__le__(self, other) 小于等于 <=
    # object.__eq__(self, other) 等于 ==
    # object.__ne__(self, other) 不等于 !=
    # object.__gt__(self, other) 大于 >
    # object.__ge__(self, other) 大于等于 >= 
    
    # __len__()获取对象的长度

    # object.__bool__(self)
    # 可以通过bool来指定对象转换为布尔值的情况
    def __bool__(self):
        return self.age > 17

    # __gt__会在对象做大于比较的时候调用，该方法的返回值将会作为比较的结果
    # 他需要两个参数，一个self表示当前对象，other表示和当前对象比较的对象
    # self > other
    def __gt__(self , other):
        return self.age > other.age


# 创建两个Person类的实例        
person = Person('宋江', 18)
person1 = Person('卢俊义', 28)

# 打印p1
# 当我们打印一个对象时，实际上打印的是对象的中特殊方法 __str__()的返回值
print(person) # <__main__.Person object at 0x04E95090>
print(person)
print(person1)

print(repr(person))

t = 1,2,3
print(t) #print:(1, 2, 3)

print(person > person1) #print:False
print(person1 > person) #print:True

print(bool(person)) #print:True

if person :
    print(person.name, '已经成年。')
else :
    print(person.name, '还未成年。')
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

标准库

# 引入sys模块
import sys

print(sys)


# sys.argv
# 获取执行代码时，命令行中所包含的参数，该属性是一个列表，列表中保存了当前命令的所有参数
print(sys.argv)

# sys.modules
# 获取当前程序中引入的所有模块
# modules是一个字典，字典的key是模块的名字，字典的value是模块对象
#print(sys.modules)

# pprint 模块它给我们提供了一个方法 pprint() 该方法可以用来对打印的数据做简单的格式化
import pprint

#pprint.pprint(sys.modules)

# sys.path
# 它是一个列表，列表中保存的是模块的搜索路径。
#pprint.pprint(sys.path)

# sys.platform
# 表示当前Python运行的平台
print(sys.platform)

# sys.exit()
# 函数用来退出程序
#sys.exit('程序出现异常，结束！')
#print('hello')

# os模块让我们可以对操作系统进行访问
import os

print(os)

# os.environ
# 通过这个属性可以获取到系统的环境变量
#pprint.pprint(os.environ['path'])

# os.system()
# 可以用来执行操作系统的dos命令。
#os.system('dir')
#os.system('notepad')
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
35
36
37
38
39
40
41
42
43
44
45
46

markdown

全新的 KaTeX数学公式 语法；
增加了支持甘特图的mermaid语法¹ 功能；
增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能，功能按钮位于编辑区域与预览区域中间；

功能快捷键

撤销：Ctrl/Command + Z
重做：Ctrl/Command + Y
加粗：Ctrl/Command + B
斜体：Ctrl/Command + I
标题：Ctrl/Command + Shift + H
无序列表：Ctrl/Command + Shift + U
有序列表：Ctrl/Command + Shift + O
检查列表：Ctrl/Command + Shift + C
插入代码：Ctrl/Command + Shift + K
插入链接：Ctrl/Command + Shift + L
插入图片：Ctrl/Command + Shift + G
查找：Ctrl/Command + F
替换：Ctrl/Command + G

如何改变文本的样式

强调文本 强调文本

加粗文本 加粗文本

标记文本

~~删除文本~~

引用文本

H₂O is是液体。

2¹⁰ 运算结果是 1024.

插入链接与图片

链接: link.

图片: Alt

带尺寸的图片:

居中的图片: Alt

居中并且带尺寸的图片:

当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。

如何插入一段漂亮的代码片

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';
1
2

生成一个适合你的列表

项目
- 项目
  - 项目

项目1
项目2
项目3

计划任务
完成任务

创建一个表格

一个简单的表格是这么创建的：

项目	Value
电脑	$1600
手机	$12
导管	$1

设定内容居中、居左、居右

使用:---------:居中
使用:----------居左
使用----------:居右

第一列	第二列	第三列
第一列文本居中	第二列文本居右	第三列文本居左

SmartyPants

SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如：

TYPE	ASCII	HTML
Single backticks	`'Isn't this fun?'`	‘Isn’t this fun?’
Quotes	`"Isn't this fun?"`	“Isn’t this fun?”
Dashes	`-- is en-dash, --- is em-dash`	– is en-dash, — is em-dash

创建一个自定义列表

Markdown

Text-to- HTML conversion tool

Authors

John

Luke

如何创建一个注脚

一个具有注脚的文本。²

注释也是必不可少的

Markdown将文本转换为 HTML。

KaTeX数学公式

您可以使用渲染LaTeX数学表达式 KaTeX:

Gamma公式展示 $\Gamma(n) = (n-1)!\quad\forall n\in\mathbb N$ 是通过欧拉积分

$\Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,.$

你可以找到更多关于的信息 LaTeX 数学表达式here.

新的甘特图功能，丰富你的文章

关于 甘特图 语法，参考这儿,

UML 图表

可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图：

这将产生一个流程图。:

关于 Mermaid 语法，参考这儿,

FLowchart流程图

我们依旧会支持flowchart的流程图：

关于 Flowchart流程图 语法，参考这儿.

导出与导入

导出

如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ，生成一个.md文件或者.html文件进行本地保存。

导入

如果你想加载一篇你写过的.md文件，在上方工具栏可以选择导入功能进行对应扩展名的文件导入，
继续你的创作。

mermaid语法说明 ↩︎
注脚的解释 ↩︎

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/272328

Python_00000_python将李敏和赵四的信息在创建阶段就加入到列表中。将李艳的信息加入到列表,放

目录

计算机基础

计算机的使用方式

Windows的命令行

path环境变量

进制

文本文件和字符集

Sublime Text 3

基本设置

Python入门

什么是计算机语言

编译型语言和解释型语言

Python的介绍

Python开发环境搭建

Python的交互界面

Python与Sublime的整合

几个概念

基本语法

字面量和变量

变量和标识符

数据类型

类型检查

对象（object）

对象的结构

变量和对象

类型转换

运算符(操作符)

流程控制语句

简介

条件判断语句（if语句）

循环语句

循环嵌套

break和continue

小游戏 《唐僧大战白骨精》

数据结构

列表（list）

切片

通用操作

序列（sequence）

修改元素

列表的方法

遍历列表

练习

range

元组

可变对象

字典（dictionary）

遍历字典

集合（set）

exercise problems

编码题

函数与模块

函数（function）简介

不定长参数

返回值

文档字符串

作用域与命名空间

递归

练习一

练习二

函数式编程

高阶函数

装饰器

模块

第三方模块的安装

exercise problems

简单题

编码题

异常

文件

文件打开

文件关闭

文件读取

文件写入

文件

案例

exercise problems

编码题

面向对象

小游戏《唐僧大战白骨精》