【Python基础知识整理】

一、Python的基本信息 

1、Python的起源

Python的创始人是吉多·范罗苏姆

Python的创作过程

 吉多对于Python的定位

2、Python的基本工作机制

一个用编译性语言比如C或C++写的程序可以从源文件（即C或C++语言）转换到一个你的计算机使用的语言（二进制代码，即0和1）。这个过程通过编译器和不同的标记、选项完成。

运行程序的时候，连接/转载器软件把你的程序从硬盘复制到内存中并且运行。而Python语言写的程序不需要编译成二进制代码。你可以直接从源代码运行程序。

在计算机内部，Python解释器把源代码转换成称为字节码的中间形式，然后再把它翻译成计算机使用的机器语言并运行。

3、Python的特点

优点：

①、简单易学

阅读一个良好的Python程序就感觉像是在读英语，使你能够专注于解决问题而非搞明白语言本身。

相对于其他语言，Python的代码量较少。

Python有极其简单的说明文档 。

用Python语言编写程序的时无需考虑诸如如何管理你的程序使用的内存一类的底层细节。

②、免费、开源，拥有良好的社区生态

Python是FLOSS（自由/开放源码软件）之一。使用者可以自由地发布这个软件的拷贝、阅读它的源代码、对它做改动、把它的一部分用于新的自由软件中。FLOSS是基于团体分享知识的概念。

③、解释性

可以以注释的形式说明程序的作用

④、可移植性

由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。这些平台包括Linux、Windows、Mac以及Google基于linux开发的android平台等。Python 作为一门解释型的语言，它天生具有跨平台的特征，只要为平台提供了相应的 Python 解释器，Python 就可以在该平台上运行

⑤、面向对象

Python既支持面向过程的编程也支持面向对象的编程。在“面向过程”的语言中，程序是由过程或仅仅是可重用代码的函数构建起来的。在“面向对象”的语言中，程序是由数据和功能组合而成的对象构建起来的。函数、模块、字符串都是对象，在Python中一切皆对象

⑥、可扩展性

Python 的可扩展性体现为它的模块，Python 具有脚本语言中最丰富和强大的类库，这些类库覆盖了文件 I/O、GUI、网络编程、数据库访问、文本操作等绝大部分应用场景。Python 可扩展性一个最好的体现是，当我们需要一段关键代码运行的更快时，可以将其用 C 或 C++ 语言编写，然后在 Python 程序中使用它们即可。

⑦、可嵌入性

可以把Python嵌入C/C++程序，从而向程序用户提供脚本功能。

⑧、丰富的库

Python标准库确实很庞大。它可以帮助处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk和其他与系统有关的操作。这被称作Python的“功能齐全”理念。除了标准库以外，还有许多其他高质量的库，如wxPython、Twisted和Python图像库等等。

⑨、规范的代码

Python采用强制缩进的方式使得代码具有较好可读性。而Python语言写的程序不需要编译成二进制代码。 

缺点：

①运行速度慢（解释型语言的速度慢于编译型语言，但是Python的可扩展性会在一定程度上改善这种情况）

②中文资料匮乏，国内市场狭小

4、Python的应用领域

web服务器应用开发、云基础设施开发、网络数据采集（爬虫）、数据分析、量化交易、机器学习、深度学习、自动化测试、自动化运筹等等

5、如何理解Python是“胶水语言”？

胶水语言（glue language）是用来连接软件组件的程序设计语言（通常是脚本语言）

胶水语言：使用输入输出命令，接口，动态链接库，静态链接库，服务，对象等。

在终端上：

可以随意地组合Python和其它程序，作为一个中间处理模块。而且，一些简单的脚本只需要cat一下马上就能明白是什么意思。一个表达式一行代码，代码块有一致的标准的缩进，标准的命名方式，简练的语言，支持注释……别的程序要访问或调用，一个命令把指定数据输入到这里就好，然后要怎么拼接怎么拼接；周期性地处理也没问题，输出到文件，等待别的程序调用。 

系统脚本上：

Python比SHELL多了很多数学及字符串处理能力，还多了很多很好用的迭代方法，还多了很多的原生的数据结构； 比PERL多了很要命的代码可读性。比起ruby和nodejs，他基本所有机器都预装，而且已经经历了时间的考验；比起C/C++，他多了一个终端、甚至像ipython这样的加强版神器终端，可以边调试代码边把没问题的代码写进文件。而且，源码即可执行。

二、名词解释

1.计算机科学/算法/软件/硬件/硬盘/内存/操作系统

计算机科学：计算设备的研究以及计算本身的研究，包括算法。

算法：如何完成一项任务的逐步描述。

软件：计算机程序的总和

硬件：组成计算机的物理组件

CPU/中央处理单元：其功能主要是解释计算机指令以及处理计算机软件中的数据。CPU是计算机中负责读取指令，对指令译码并执行指令的核心部件。

内存/随机存取存储器：暂时存储程序以及数据包括暂时存放CPU中的运算数据、与硬盘等外部存储器交换的数据。它是外存与CPU进行沟通的桥梁，计算机中所有程序的运行都在内存中进行，内存性能的强弱影响计算机整体发挥的水平。只要计算机开始运行，操作系统就会把需要运算的数据从内存调到CPU中进行运算，当运算完成，CPU将结果传送出来。内存的运行决定计算机整体运行快慢。

内存存储单元位指代单个二进制数字，字节(B)指代一组8个2进制的数字；千字节(KB)、兆字节(MB)、千兆字节(GB)、太字节(TB)、拍字节(PB)间的转化比例有1024、1000等不同转化比例，按语境分析。

硬盘：计算机的永久性储存区域。

操作系统：当用户选择要运行操作系统中的一个程序的时候，该程序的指令从硬盘加载到计算机的内存，操作系统为该程序分配内存，运行程序的指令从内存送到CPU并按照顺序执行。

2.解释器/编译器/解释/编译/字符编码表

解释器：用来处理代码编译的软件，编译器以解释方式运行

编译器：将其他语言翻译成机器语言的工具。编译器翻译的方式有两种——编译和解释，两种方式的区别在于翻译时间点的不同

解释：逐句翻译高级语言编写的源程序，边翻译边执行；编译：将Python、Java等编程语言的代码翻译成机器语言的过程。解释和编译本身没有区别，不过是适用不同场景。

 字符编码表（本质上是建立起机器语言和自然语言之间的关系）

3.机器语言/自然语言/编译语言/解释型语言/编译型语言/高层语言

机器语言：0、1组合的电脑能够直接处理的指令。需要注意的是：计算机不能直接理解任何除机器语言以外的语言

编程语言：用来定义计算机程序的形式语言，人和计算机交流的语言

解释型语言：逐行编译，逐行执行；编译型语言： 统一编译，一次执行。

        Ps:编译型语言执行速度快；但是不具备跨平台执行能力

高层语言/高层次语言：包括C、C++、SystemC等，通常有较高的抽象度，并且往往不具有时钟或时序的概念。”

4.程序/空白/源代码/伪代码/源文件/程序分解/流程图/程序错误

程序：计算机可以执行的指令列表；应用程序/APP：在操作系统内运行的程序。为了让程序更加可读，有一些简单的规则需要遵循：①将每个语句单独放在一行上；②在print语句、括号和其他语法周围使用一致的间距；③使用空行分隔语句组或程序的相关部分；④通过一致数量的空格或制表符来缩进，注意每个缩进级别有四个空格。

空白：程序中出现的空白符，包括空格、制表符、换行符。

源代码/源程序：指未编译的按照一定的程序设计语言规范书写的文本文件，是一系列人类可读的计算机语言指令。 在现代程序语言中，源代码最为常用的格式是文本文件。计算机源代码的最终目的是将人类可读的文本翻译成为计算机可以执行的二进制指令，这种过程叫做编译，通过编译器完成。

伪代码：一种非正式的，类似于英语结构的，用于描述模块结构图的语言。使用伪代码的目的是使被描述的算法可以容易地以任何一种编程语言（Pascal，C，Java等）实现。因此，伪代码必须结构清晰、代码简单、可读性好，并且类似自然语言。 介于自然语言与编程语言之间。以编程语言的书写形式指明算法职能。使用伪代码， 不用拘泥于具体实现。

源文件：文件是指由创建者所定义的、具有文件名的一组相关元素的集合。源文件一般指用汇编语言或高级语言写出来的代码保存为文件后的结果，源文件是相对目标文件和可执行文件而言的。

程序分解：将问题分解为可管理的部分并单独解决每个问题来建构问题的解决方案；即将复杂任务分解为一组子任务，逐一完成即可。

迭代增强：分阶段编写程序并且每个阶段增加新功能的过程，在每个迭代步骤不断测试，以确保该部件在继续开发之前能够正常正确工作。

流程图/程序框图:以特定的图形符号加上说明，表示算法的图。

程序阻塞：

程序错误：语法错误、逻辑错误、运行时错误。

        语法错误

【实例】程序破坏了Python的语法规则，解释器会在将你的程序从Python转化为可执行指令出错时尝试报告语法错误。错误信息报告traceback（错误信息与追溯）中会包括错误发生时程序执行的状态、错误位置，可能的错误类型和错误细节

print(int("99.88"))
Traceback (most recent call last):
  File "S:\python\pythonProject\main.py", line 8, in <module>
    print(int("99.88"))          
ValueError: invalid literal for int() with base 10: '99.88'

        逻辑错误 / bug——调试：查找和消除bug

        运行时错误

运行时错是指程序合法但无法成功运行，例如计算机计算一个无效值、程序尝试从不存在的文件中读取数据、调用函数自身的函数（RecursionError,递归错误/超过递归深度限制）

# 运行时错误的例子
def lover():
    print("相逢的人会再相逢，该走的人终会离开")
    lover()
 
 
lover()

5.镜像源/集成开发环境/交互式编程/控制台窗口

镜像源：提供软件下载的地方。Python 的默认镜像源是国外的，在国内的网络环境下访问不太稳，于是下载速度也就比较慢。        

集成开发环境：用于创建、编辑、编译、执行程序文件的一体化环境，汇集了书写代码、开发软件所需要的各种工具。包括图形用户界面、代码编辑器（支持自动缩进、代码补全）、编译器/解释器、调试器（断电和单步执行）

交互式编程：直接在终端上运行解释器，而不使用文件名的方式来执行程序。也可以称之为REPL——读取(read)输入的内容、执行(eval)用户输入的指令、打印(print)执行结果、最后进行循环(loop)。Python支持交互式编程。

控制台窗口：Python程序与用户交互的一个纯文本窗口。其中计算机在屏幕上限是文本并且又是等待用户键入响应的是控制台交互/终端交互；计算机打印到控制台窗口的文本称为程序的输出；程序运行时用户键入的任何信息称为控制台输入。

6.格式化/转义字符/注释/语句/语法模块

格式化：把同类事物处理成相同的规格、样式。pycharm中的快捷键是 ctrl+alt+l

转义字符/转义序列：用于表示特殊字符的双字符序列，均以反斜杠字符“\”开头。

        常见应用场景：1：将普通字符转为特殊用途，一般是编程语言中，用于表示不能直接显示的字符，比如后退键，回车键，等。2：用来将特殊意义的字符转换回它原来的意义。常用在正则表达式中。转义字符“ \ ”+想要实现功能的首字母：“ \r ”回车（覆盖上一项）； “ \t ”水平制表符（4位的空格）； “ \n ”换行；“ \\ ”一个反斜杠字符；“ \' ”单引号，在单引号字符串中；   " \'' "双引号，在双引号字符串中；“ \b ”退格（返回上一步骤）。

print(int(float("99.88")))
print("He argue that \"what \'it\' reflect?\nI think……")
"""He argue that "what 'it' reflect?
I think……
"""
 
print(r'hello\nword')  # hello\nword
print(r'hello\nworld\\')  # 如果不希望转义字符发挥作用，可以在最前面添加“r”
print('hello\nworld')  # 换行

注释：用来向用户提示或解释某些代码的作用和功能，它可以出现在代码中的任何位置。Python 解释器在执行代码时会忽略注释，不做任何处理；在调试（Debug）程序的过程中，注释还可以用来临时移除无用的代码。注释的最大作用是提高程序的可读性。

        Python 支持两种类型的注释，分别是单行注释和多行注释。Python 使用哈希符号#作为单行注释的符号，语法格式为：# 注释内容 ；从#开始，直到这行结束为止的所有内容都是注释。Python 解释器遇到#时，会忽略它后面的整行内容。多行注释指的是一次性注释程序中多行的内容（包含一行）。多行注释通常用来为 Python 文件、模块、类或者函数等添加版权或者功能描述信息。Python 多行注释不支持嵌套。在注释内容的开始和结尾分别使用三个单引号/双引号注释多行内容

        注释除了给代码添加说明以外还有另外一个实用的功能，就是用来调试程序。如果猜测某段代码可能有问题，可以先把这段代码注释起来，让 Python 解释器忽略这段代码，然后再运行。如果程序可以正常执行，则可以说明错误就是由这段代码引起的；反之，如果依然出现相同的错误，则可以说明错误不是由这段代码引起的。在调试程序的过程中使用注释可以缩小错误所在的范围，提高调试程序的效率。

        Ps : ① 说明多行代码的功能时一般将注释放在代码的上一行；说明单行代码的功能时一般将注释放在代码的右侧 ②不管是多行注释还是单行注释，当注释符作为字符串的一部分出现时，就不能再将它们视为注释标记，而应该看做正常代码的一部分。③注释的快捷操作，选择需要注释的代码范围，按住Ctrl+/ 进行注释，并在所选代码行的开头自动添加“#”。取消注释也是相同的操作。

语句：代表单个完整命令的可执行代码单元。

语法模块：

7.数据类型/科学记数法/进制

7.1数据类型分类：

7.1.1、整数类型（int / integer）可以表示正数、负数和零

       ① 整数的不同进制表示方式

                十进制—>默认的进制    逢10进1        基本数为0.1.2.3.4.5.6.7.8.9

                二进制—>以0b开头       逢2进1          基本数为0.1

                八进制—>以0o开头       逢8进1          基本数为0.1.2.3.4.5.6.7

                十六进制—>以0x开头   逢16进1        基本数为0.1.2.3.4.5.6.7.8.9.A.B.C.D.E.F

        Ps:0b1110110(2)—>0o166(8)—>118(10)—>0x76    

               使用辗转相除法和更相减损法计算不同进制下对应的数字                 

       ② 转化代码：

                将其他进制的字符转换为二进制，使用函数bin()；

                将其他进制的字符转换为八进制，使用函数oct()

                将其他进制的字符转换为十六进制，使用函数hex()

                将其他进制的字符转换为十进制，使用函数 int()     

print(bin(10))  # 0b1010
# 1 * 2 ** 3 + 0 * 2 ** 2 + 1 * 2 ** 1 + 0 * 2 ** 0 = 10
print(1 * 2 ** 3 + 0 * 2 ** 2 + 1 * 2 ** 1 + 0 * 2 ** 0)  # 10
print(bin(149))  # 0b10010101
# 转化技巧：可以被2整除，对应位数的数值就是0.
# 不可以被2整除，对应位数的数值为余数，剩余部分做整除运算
# 也可以使用计算器的程序员模式

        ③ 转化技巧 :        

        利用进制之间的关系巧妙地转化结果-----八进制、十六进制与二进制之间的倍数关系—>用等可能来代替等可能数字——八进制中的每一位需要二进制中的三位来表示，十六进制中的每一位数需要二进制中的四位来表示，不足相应位数补0

        ④Python 整数的取值范围是无限的，不管多大或者多小的数字，Python 都能轻松处理。当所用数值超过计算机自身的计算能力时，Python 会自动转用高精度计算（大数计算）。

        ⑤为了提高数字的的可读性，Python 3.x 允许使用下划线_作为数字（包括整数和小数）的分隔符。通常每隔三个数字添加一个下划线，类似于英文数字中的逗号。下划线不会影响数字本身的值。
        【实例】length = 1_301_547        distance = 384_000_000

7.1.2、浮点数类型(float) 由整数部分和小数部分组成

Ps：①浮点数储存不精确，使用浮点数进行计算时可能会出现小数位数不确定的情况②使用除法结果会变成浮点数（有小数点）

print(1.1+2.2) #3.3000000000000003
print(1.1+2.1) #3.2
 
from decimal import Decimal  #解决浮点数储存不精确的问题
print(Decimal('1.1')+Decimal('2.2')) #3.3
 
print(8/2)   #4.0

7.1.3、字符串类型

①字符串又被称为不可变的字符序列

②字符串可以使用单引号、双引号、三引号来定义；单引号和双引号定义的字符串必须在一行；三个连续的单引号定义的字符串可以分布在连续的多行；包含在一种引号中的字符串可以在其中包含其他类型的引号作为输出的一部分；在字符串中“+”起连接作用

str1='龙潜于渊，龙跃于天 '
str2="龙潜于渊，龙跃于天"
str3="""龙潜于渊，龙跃于天"""
str4='''龙潜于渊，龙跃于天'''
print(str1+str2) #龙潜于渊，龙跃于天 龙潜于渊，龙跃于天

③字符串的格式化  快捷键Alt+Ctrl+L——代码的规范

7.1.4、布尔值类型

①Python一切皆有对象，所有对象都有一个布尔值，可以使用内置函数bool()获取对象的布尔值

②布尔值可以用于计算 False=0; True=1

        【实例】print(False + 1) # 1         print(True + 1) # 2

③布尔值在纂写代码，开发软件中一般用于判断

5、其它数据类型

complex  复数        list 列表        tuple 元组        dictionary/dict  字典    set 集合

7.2、不同数据类型之间的转化

7.2.1、转化为整数

       print(int(100.99))  # 100 将浮点数转换成为整数，舍去小数部分

       print(int("100"))  # 100  将字符串转换成为整数

       print(int(True))  # 1 布尔值True转换成为整数是 1

       print(int(False)) # 0 布尔值False转换成为整数是 0

Ps : ①包含非法字符将会转换失败      

  【实例】 print(int("99.88"))        print(int("56ab"))        不能被转换成为整数

        但是print(float("99.88"))可以转化为浮点数，所以可以print(int(float("99.88")))

        ② 超出基本数范围会报错

  【实例】八进制里允许的最大值是7,所以 29 不是一个合法的八进制数    print(int("29",8))会报错

        ③使用int()函数进行类型转换，可以传入两个参数，第二个参数用来第一个参数所处的进制。

  【实例】print(int("21",8))  # 输出的结果是17.八进制的21,对应的十进制数字是17

                print(int("F0",16)) # 输出的结果是240.十六进制的F0,对应的十进制数字是240

7.2.2、转换成为浮点数

        print(float("12.34"))  # 12.34  将字符串的 "12.34" 转换成为浮点数 

        print(float(23))         # 23.0  将整数转换成为了浮点数

        print(float(True))        #1.0   将布尔值转化为浮点数

        print(float(False))      #0.0  将布尔值转化为浮点数

7.2.3、转换成为字符串

        print(str(45))        # '45'

        print(str(34.56))   # '34.56'

        print(str(True))    # 'True'

4、转换成为布尔值

        在Python中，只有空字符串''、“”、''''''、数字0，空字典{}，空列表[]，空元组()，和空数据None会被转换成为False，其他的都会被转换成为True

5、其他类型转换

 7.3、使用函数 type()可以检索数据的类型

str1=0
str2=0.0
str3='0.0'
str4=False
print(type(str1),type(str2),type(str3),type(str4),sep='  ')
# <class 'int'>  <class 'float'>  <class 'str'>  <class 'bool'>

7.4、科学计数法：一种记数的方法。把一个数表示成a与10的n次幂相乘的形式（1≤|a|<10，a不为分数形式，n为整数）。  例如：19971400000000=1.99714×10^13。计算器或电脑表达10的幂是一般是用E或e，也就是1.99714E13=19971400000000。当我们要标记或运算某个较大或较小且位数较多时，用科学记数法免去浪费很多空间和时间。

7.5、计算机使用二进制数的原因：系统建立在二元现象智商，要比建立在必须彼此区分的10种不同状态之上要简单得多；构建使用二进制数的物理设备更容易

8、变量/关键字/保留字/标识符

8.１、变量的定义

        对于重复使用，并且经常需要修改的数据，可以定义为变量，来提高编程效率。

        定义变量的语法为:　name = value，其中 “=” 的作用是赋值，  “将变量值赋值给name”

        Ps：①变量名：我们可以理解为箱子，箱子里面放的就是右侧的值。当需要使用变量值，就把对应的箱子拿来。②变量即是可以变化的量，可以随时进行修改。③程序就是用来处理数据的，而变量就是用来存储数据的。③变量没有类型，数据才有类型；变量自身可以运算

8.2、关键字/保留字/标识符

        关键字：Python中预定义的标识符，用于特定用途。只能将关键字用预期设定的用途，而不应该使用关键字作为程序中的函数名称，如果使用，会引发问题。

        保留字(reserved word)：指在高级语言中已经定义过的字，程序员不能再将这些字作为变量名、过程名或函数名使用。保留字包括关键字和未使用的保留字。关键字则指在语言中有特定含义，成为语法中一部分的那些字。在一些语言中，一些保留字可能并没有应用于当前的语法中，这就成了保留字与关键字的区别。一般出现这种情况可能是由于考虑扩展性。例如，Javascript有一些未来保留字，如abstract、double、goto等等。

        标识符：赋予程序中实体的名称，例如函数，标识符必须以字母开头，后跟任意数量的字母或数字，Python语言规范允许标识符包含下划线字符“_”,但是Python区分大小写。越有描述性的标识符，越容易理解程序的作用和目的。

8.3、变量命名的规则

                硬性规则：①变量名由字母、数字和下划线构成，数字不能开头

                                  ②区别大小写

                                 ③尽量不使用关键字或者保留字

                      Ps：如果标识符与保留字重复，系统会以自定义的标识符为主

                非硬性规则：　

                        ①变量名通常使用小写英文字母，多个单词用下划线进行连接。

                        ②受保护的变量用单个下划线开头。

                        ③私有的变量用两个下划线开头

                        ④出于便于理解的诉求，最好用便于理解的变量名来写代码，见名知义

                    Ps：变量命名驼峰式命名、大驼峰、小驼峰；

8.4、变量的使用

        8.4.1、声明变量——等号后面就是变量中存的值。如果我们想使用这个值就可以通过变量找到他们。变量名第一次出现需要定义变量，再次出现时使用变量，可以修改变量中存储的值

       【实例】 a = 45 　　#　 将数值45赋值给变量a　

        8.4.2、变量分类

                全局变量

                局部变量

                局部变量与全局变量之间的转化

                系统变量

                环境变量

        8.4.3、字符串格式 

message = '"龙潜于渊，龙跃于天"'
age = 18
money = 108.108108
print('经历了' + str(age) + '岁月的考验, 我坚信' + message)  # 字符串的连接
 
print('经历了%d岁月的考验, 我坚信 % s ' % (age, message))  # 字符串的格式化
# %d 整数（十进制）；   %f浮点数；   %s字符串：    %x/x十六进制整数；    %o八进制整数    
print('经历了%d,我坚信%s,赚取了%.2f' % (age, message, money))
# %.2f的意思是浮点数保留两位小数    %.3f的意思是浮点数保留三位小数
 
print('经历了%s,我坚信%s,赚取了%s' % (age, message, money))
# 在这种情况下，字符串格式化会自动将其它数据类型转化为str
 

9、函数

9.1、函数使用基础

定义函数：编写函数的名称和它包含的语句集合。

调用函数：执行函数中包含的语句。

主程序：Python程序中未缩进的部分，用于指定整个程序应执行的语句和函数。

main()函数，包含主程序代码的函数，指定整个程序应执行的语句与函数。

控制流：执行程序语句的顺序。每次程序遇到函数调用时，程序的执行“跳转”到该函数，按顺序执行该函数中的每个语句，然后“跳转”回调用处继续执行。

"""
def name():
    statement
    statement
语法模块：定义一个函数
"""
#冒号表示语句序列的开头；属于该函数的每个语句都必须缩进 Tab；Python可以自动缩进
 
def for_love():
    print("有情人终成眷属")
 
#    定义函数    
 
for_love()      #调用函数；可以多次调用同一个函数
 
 
 
'''main()函数的使用'''
def for_love():
    print("静待花开，有情人终成眷属")
 
 
def forever():
    print("认真地体味青春，认真地老去")
 
 
def main():
    forever()
    for_love()
 
 
main()

9.2、参数

        形式参数

        实际参数

9.3、常见的内置函数

        type(name) 用来查看变量的数据类型；

        id(name) 用来查找数据在内存空间中的位置信息； 

        input('提示语句')   用来接收来自用户的输入数据，输入数据的类型为str，如果需要其他类型的数据，需要将数据类型转换；另外，需要一个变量来存储这个数据，即 name = input()

        print 函数可以输入文本、数字、字符串、表达式、指定位置的文件内容       

        chr()

        ord()

        dir(math)

9.3、函数的返回值

10、运算符

10.1、算术运算符

Ps :  ①混合运算时，优先级顺序为： ** 高于 * / % // 高于 + - ，为了避免歧义，建议使用 () 来处理运算符优先级。

        ②不同类型的数字在进行混合运算时，整数将会转换成浮点数进行运算。

        ③如果是两个字符串做加法运算，会直接把这两个字符串拼接成一个字符串；如果是数字和字符串做加法运算，会直接报错；如果是数字和字符串做乘法运算，会将这个字符串重复多次。

10.2、赋值运算符

10.2.1、基本赋值运算符

单个变量赋值    number=10

多个变量赋值     number1，number2 = 1 , 2   （系列解包赋值）;

                          a = b =10；（链式赋值）

                         ｘ，ｙ＝ｙ，ｘ（ｘ，ｙ交换数值）

Ps : 变量的个数要和值的个数一一对应，否则就会出现赋值错误

10.2.2、复合赋值运算符

        Ps：注意：赋值运算符是从右往左运算，将等号右边的值赋值给等号左边，所以，等号的左边一定不能是常量或者表达式。　　实例：ａ＋＝２＊１０——＞ａ＝２＊１０＋ａ

10.3、逻辑运算符

a = 1
b = 2
c = 0
print(a and b)  # 2
print(b and a)  # 1
print(a or b)  # 1
print(b or a)  # 2
print(a or c)  # 1
print(a and c)  # 0
print(b or c)  # 2
print(b and c)  # 0
​
print(45 and 28 and 'hello' and 0)  # 0　（取第一个为False的值）
print(0 or None)  # None（如果所有的值都为False,取最后一个值。）
print(0 or "" or None)  # None（如果所有的值都为False,取最后一个值。）
 
​

10.4、关系运算符

（ is 、< 、> 、<= 、>= 、!=  、==）

关系运算符的运算结果是布尔值

Ps :赋值运算符中‘＝’、比较运算符中‘＝＝’、变量由三部分组成：标识，数值　　分析三者的区别

list1 = [11, 22, 33, 44]
list2 = [11, 22, 33, 44]
print(list1 == list2)  # True
print(list1, id(list1))  # [11, 22, 33, 44] 2126707372672
print(list2, id(list2))  # [11, 22, 33, 44] 2126707372224
print(list1 is list2)  # False

10.5、位运算符（——针对二进制的运算）

number1 = 6
number2 = 2
print(bin(number1), bin(number2))  # 0b110 0b10
print(number1 & number2)  # 2
print(bin(number1 & number2))  # 0b10
# 0&0——>0； 0&1——>0； 1&0——>0； 1&1——>1; 1为真，0为假，&类似and;对应数位都是1，结果才是1，否则为0
 
print(number1 | number2)  # 6
print(bin(number1 | number2))  # 0b110
# 0|1——>1;  1|1——>1; 0|0——>0; 1|0——>1; 1为真，0为假，|类似or；对应数位都是0，结果数位才是0，否则为1
 
print(number1 ^ number2)  # 4
print(bin(number1 ^ number2))  # 0b100
# 上下两个数为相同为0，不同为1，^——>异或
 
number = 2
print(4 << number)  # 向左移动 number位，相当于乘以2的number次方
# 左移位运算符 <<，高位溢出舍弃，低位补0
print(4 >> number)  # 向右移动 number位，相当于整除2的number次方
# 右移位运算符 >>，低位溢出舍弃，高位补0
#   ~取反；     判断是否是负的二进制的依据，看二进制的最高位，最高位为1则为负数，最高位为0则为正数
print(~7)  # 将7的二进制取反 ——>  -8
# ~7的十进制表示：1.先求+7的二进制0000 0111   2.反码 1111 1000  3.补码 1111 1001
print(~-5)  # 将-5的二进制取反 ——>  4
# ~ -5的十进制表示：1. 0000 0101——>： 2.取反： 1111 1010——>：3. +1：1111 1011     4.取反： 0000 0100
# 已知十进制负数，求二进制负数：1.正数的原码 2.原码取反 3. +1 ——>十进制负数的二进制表示
# 【例】 -9的二进制表示：00001001 ——> 11110110 ——> 11110111
# 已知二进制的负数，求对应的十进制表示： ——二进制负数的十进制表示
# 1.二进制负数 21.二进制-1 3.取反 4.原码：将原码转化为十进制，在十进制的前面添加 -
# 【例】11111101的十进制表示： 1.减1： 1111 1100   2.取反：0000 0011    3.原码0000 0011 4.十进制：-3

10.6、比较运算符

Ｐｓ：①数字和字符串做==运算结果是false,除了 == 以外的逻辑运算时，会直接报错。

　　　②如果是两个字符串进行比较，会将每个字符都转换成对应的编码，然后逐一进行对比。

str1='a' 
str2='ABC'
# 将字符转换成为对应的编码  a对应的编码是97,A对应的编码是65
print(str1 > str2)    ＃True

10.7、运算符的优先级

以下表格列出了从最高到最低优先级的所有运算符：

# 运算的优先级
a = 1
b = 2
x = 20
print(b > a + x < a + b)  # False
print(b > a + (x < a + b))  # True
print(a + False)  # 1

11、字符串

11.1、字符串定义

Python 要求字符串必须使用引号括起来，使用单引号也行，使用双引号也行，只要两边的引号能配对即可。字符串引号里面的的每个基本单元叫做字符，比如字符"abc"中，"a"、"b"和"c"就是字符串组成的基本单元，它们都是字符。

如下定义的变量，存储的是字符串类型的值

    a = "I'm Bob"  # 一对双引号 
    b = 'I am Bob'  # 一对单引号
    c = 'He said:I\'m Bob'  # 当出现符号冲突时可以使用转义字符说明
    d = '''I'm Bob'''  # 三个单引号
    e = """I'm Bob """  # 三个双引号

小总结：

• 双引号或者单引号中的数据，就是字符串

• 如果使用一对引号来定义字符串，当出现符号冲突时可以使用转义字符，比如变量c

• 使用三个单引号或者三个双引号定义的字符串可以包裹任意文本

11.2、字符串的运算

1.使用+运算符来实现字符串的拼接; 使用*运算符来重复一个字符串的内容

s1 = 'hello' + ' ' + 'world'
print(s1)    # 结果：hello world
s2 = '!' * 3
print(s2)    # 结果：!!!
s1 += s2     
print(s1)    # 结果：hello world!!!
s1 *= 2      
print(s1)    # 结果：hello world!!!hello world!!!

2.使用in和not in来判断一个字符串是否包含另外一个字符串。

str1 = 'bxah'
str2 = 'b'
str3 = 'bx'
str4 = 'bh'
print(str2 in str1)  # True ——>单个字符没有位置区分
print(str3 in str1)  # True
print(str4 in str1)  # False——>多个字符组成的新字符串有字符内在位置的区分
print(str4 not in str1) # True

3.对于两个字符串类型的变量，可以直接使用比较运算符比较两个字符串的相等性或大小。

Ps: ①因为字符串在计算机内存中也是以二进制形式存在的，那么字符串的比较其实比的是：每个字符对应的编码的大小。可以使用ord函数来获得字符对应的编码，例如ord('A')的值是65，而ord('赵')的值是36213。

      ②字符串的比较运算比较的是字符串的内容，Python中还有一个is运算符（身份运算符），如果用is来比较两个字符串，它比较的是两个变量对应的字符串是否在内存中相同的位置（内存地址id），简单的说就是两个变量是否对应内存中的同一个字符串。

【例】

1.A的编码是65， 而a的编码是97，所以'A' < 'a'的结果相当于65 < 97的结果，——>True；

2.'boy' < 'bad'，因为第一个字符都是'b'比不出大小，所以实际比较的是第二个字符的大小，显然'o' < 'a'的结果是False，所以'boy' < 'bad'的结果也是False。

11.3、字符串的索引与切片

Ps:1.在进行索引操作时，如果索引越界（正向索引不在0到N-1范围，负向索引不在-1到-N范围）会引发IndexError异常，错误提示信息为：string index out of range（字符串索引超出范围）

2.从字符串中取出多个字符，我们可以对字符串进行切片，运算符是[i:j:k]，其中i是开始索引，索引对应的字符可以取到；j是结束索引，索引对应的字符不能取到；k是步长，默认值为1，表示从前向后获取相邻字符的连续切片，所以:k部分可以省略。

3.假设字符串的长度为N，当k > 0时表示正向切片（从前向后获取字符），如果没有给出i和j的值，则i的默认值是0，j的默认值是N；当k < 0时表示负向切片（从后向前获取字符），如果没有给出i和j的值，则i的默认值是-1，j的默认值是-N - 1。第一个字符的索引是0或-N，最后一个字符的索引是N-1或-1，最中间的索引可以表示为len(name)//2

'''字符串的切片——格式：name[start,stop,step],
索引的顺序控制着输出字符串的组成顺序，相应位置未填写就是默认数据
step 的正负可以影响索引的顺序——从左到右还是从右到左
注意：索引中start和stop对应的顺序和step的顺序不能相悖，但是索引可以兼用正向索引和负向索引来表示'''
import random
 
string = 'QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm0123456789'
print(len(string))  # 62
print(string[:60:7])  # QIGCepjb4
print(string[4::9])  # TFVygb6
print(string[4::])  # 从4开始到结尾
print(string[-15:-2:3])  # cn147
print(string[:-1:2])#奇数索引的——QETUOADGJLXVNqetuoadgjlxvn02468
print(string[1::2])#偶数索引——WRYIPSFHKZCBMwryipsfhkzcbm13579
print(string[2:-1:5])#EIDKVwusjc05
print(string[21:-15:7])#Cepj

11.4、字符串的循环遍历

从字符串中取出每个字符，可以使用for循环对字符串进行遍历，有两种方式。

# 方法一
string='hello'
for index in range(len(string)):
     print(string[index],end='  ')
 
print()
# 方法二
string='hello'
for i in string:
    print(i,end='  ')

11.5、字符串的查询

# 字符串的查询——字符串索引机制 索引——>正索引 0~n ; 负索引 -1~-n
# 字符串中的每个字符都有表示位置的下标值，下标范围从左往右从0开始依次增加或者从右往左从-1开始依次减少。
str = 'NSDFKJHF'
print(str[5])  # J
print(len(str))  # 8
print(str[-3])  # J

11.6、字符串的修改

# 字符串的修改
s1 = 'hi world !'
print(id(s1), id(s2), sep='\n')  # s1和s2的ID不同，s1的id发生变化，s2没有

11.7字符串的赋值

# 字符串的赋值
s1 = 'hello world!'
s2 = s1
s3 = 'hello world!'
s4 = 'hello !'
print(id(s1), id(s2), id(s3), id(s4), sep='\n')  # id相同
# id相同——数据储存位置相同——输出内容相同

11.8、字符串的操作方法

在Python中，我们可以通过字符串类型自带的方法对字符串进行操作和处理，对于一个字符串类型的变量，我们可以用变量名.方法名()的方式来调用它的方法。所谓方法其实就是跟某个类型的变量绑定的函数

        11.8.1、获取长度len

s = 'hello, world'
print(len(s))                  # 12
print(len('goodbye, world'))    # 14

        11.8.2、查找内容find\rfind\index\rindex

s = 'hello, world!'
'''
find方法从字符串中查找另一个字符串所在的位置,找到了返回匹配的字符串的首字母下标，没有找到则返回-1
'''
print(s.find('or'))        # 8——>o的索引——字符串首字母的索引
print(s.find('good'))      # -1
# 通过方法的参数来指定查找的范围——查找不必从索引为0的位置开始
# find方法的逆向查找rfind，从右侧开始查找字符串,没有找到返回-1
 
# index方法与find方法类似，# 找到了返回字符串中另一个字符串首字符的索引，找不到引发异常
print(s.index('or'))       # 8
print(s.index('good'))     # ValueError: substring not found
# 通过方法的参数来指定查找的范围——查找不必从索引为0的位置开始
# index方法的逆向查找rindex
 
s = 'hello good world!'
# 从前向后查找字符o出现的位置(相当于第一次出现)
print(s.find('o'))       # 4
# 从索引为5的位置开始查找字符o出现的位置
print(s.find('o', 5))    # 7
# 从后向前查找字符o出现的位置(相当于最后一次出现)
print(s.rfind('o'))      # 12

        11.8.3、判断startwith\endswith\isalpha\isdigit\isalnum\isspace\isupper\islower

s1 = 'hello, world!'
 
# startwith方法检查字符串是否以指定的字符串开头,返回布尔值
print(s1.startswith('He'))    # False
print(s1.startswith('hel'))   # True
# endswith方法检查字符串是否以指定的字符串结尾,返回布尔值
print(s1.endswith('!'))       # True
 
s2 = 'abc123456'
 
# isdigit方法检查字符串是否由数字构成,返回布尔值
print(s2.isdigit())    # False
# isalpha方法检查字符串是否以字母构成,返回布尔值
print(s2.isalpha())    # False
# isalnum方法检查字符串是否以数字和字母构成,返回布尔值
print(s2.isalnum())    # True
# isspace方法检查字符串是否是空白字符串，返回布尔值
print(s2.isspace())    # False
 
string = 'ajkahk123'
result1 = string.isupper()#字母部分是否都是小写字母
result2 = string.islower()#字母部分是否都是大写字母
print(result1, result2)  # False True
 

        11.8.4、统计指定字符出现的个数count

web_string = 'https://cn.bing.com/images/search?q=%E5%9B%BE%E7%89%87&FORM\
        =IQFRBA&id=2A67B025EDB55DFCC3EAB049289AB0CD4D0A72B5'
times = web_string.count('%')
print(times)  # 6

        11.8.5、替换内容repalce

string1 = '龙潜于渊，龙跃于天'
result1 = string1.replace('龙', '鹰')
result1 = string1.replace('龙', '鹰', 1)
print(result1)
# replace(old,new,count)——>默认全部替换，也可以通过count指定处数

        11.8.6、切割字符串split\rsplit\splitiness\partition\rpartition

string1 = '龙潜于渊，龙跃于天'
result1 = string1.replace('龙', '鹰')
result1 = string1.replace('龙', '鹰', 1)
print(result1)
# replace(old,nem,count)——>默认全部替换，也可以通过count指定次数
 
string2='白起, 廉颇, 赵胜、赵奢、王翦'
result2 = string2.split()
print(result2)  # ['白起、廉颇、赵胜、赵奢、王翦']
result3=string2.split('、',2)
print(result3)#['白起', '廉颇', '赵胜、赵奢、王翦']
# split('分隔符', maxsplit)  返回的结果是一个列表，maxsplit是指最多的分割次数
 
string4 = '''曾经沧海难为水
除却巫山不是云
取次花丛懒回顾
半缘修道半缘君'''
result4 = string4.splitlines()#按照行数分割
print(result4)  # ['曾经沧海难为水', '除却巫山不是云', '取次花丛懒回顾', '半缘修道半缘君']
 
string5='悟空 八戒 沙僧'
result5=string5.partition(' ')
print(result5)#'悟空', ' ', '八戒 沙僧')

        11.8.7、修改大小写capitalize\title\upper\lower

s1 = 'hello, world!'
 
# 使用capitalize方法获得字符串首字母大写后的字符串
print(s1.capitalize())   # Hello, world!
# 使用title方法获得字符串每个单词首字母大写后的字符串
print(s1.title())        # Hello, World!
# 使用upper方法获得字符串大写后的字符串
print(s1.upper())        # HELLO, WORLD!
s2 = 'GOODBYE'
# 使用lower方法获得字符串小写后的字符串
print(s2.lower())        # goodbye

        11.8.8、空格处理lstrip\rstrip\strip

strip方法可以将原字符串修剪掉左右两端空格，通常用来将用户不小心键入的头尾空格去掉

lstrip方法可以将原字符串修剪掉左端空格；rstrip方法可以将原字符串修剪掉右端空格

string = '  hello,world!  '
result1 = string.strip()  # 删除字符串左右两侧空白字符
print(result1)
result2 = string.lstrip()  # 删除左侧空白字符
print(result2)
result3 = string.rstrip()  # 删除右侧空白字符
print(result3)

        11.8.9、字符串拼接join

string1 = 'hello' + ',' + 'world' + '!'
print(string1)  # hello,world!
'''字符串拼接——>把参数进行遍历(左闭右开)，取出参数的每一项，然后再在后面加上mystery
 mystery=''
 mystery.join('')'''
mystery = '-*-'
print(mystery.join('family'))  # f-*-a-*-m-*-i-*-l-*-y
# 把family一个个取出来，并在后面添字符-*-，最后的y保留，没有添加-*-
txt = '_'
print(txt.join(('good', 'hi', 'hello')))  # good_hi_hello
print(txt.join(['happy', 'delight', 'excitement']))  # happy_delight_excitement
# 字符串拼接可以把列表或者元组快速的转变成为字符串，并且以指定的字符分割

        11.8.10、对齐方式center、rjust、ljust

# 添加空格控制字符串的对齐方式
string1 = ' hello , world '
result4 = string1.center(20)  # 居中对齐，左右各20个像素位置
print(result4)
result5 = string1.ljust(30)  # 左对齐，左侧30个像素位置
print(result5)
result6 = string1.rjust(30)  # 右对齐，右侧30个像素位置
print(result6)

        11.8.11、字符串编码和解码

对字符串进行匹配检查，即检查字符串是否满足某种特定的模式。例如，一个网站对用户注册信息中用户名和邮箱的检查，就属于模式匹配检查。实现模式匹配检查的工具叫做正则表达式，Python语言通过标准库中的re模块提供了对正则表达式的支持

11.9、格式化字符串

1.在Python中，字符串类型可以通过center、ljust、rjust方法做居中、左对齐和右对齐的处理。

s = 'hello, world'
 
# center方法以宽度20将字符串居中并在两侧填充*
print(s.center(20, '*'))  # ****hello, world****
# rjust方法以宽度20将字符串右对齐并在左侧填充空格
print(s.rjust(20))        #         hello, world
# ljust方法以宽度20将字符串左对齐并在右侧填充~
print(s.ljust(20, '~'))   # hello, world~~~~~~~~
# 左对齐、右对齐、居中对齐 中的宽度、填充的字符可以自定义

2.

# 用print函数输出字符串时，对字符串进行格式化。
a = 321
b = 123
print('%d * %d = %d' % (a, b, a * b))
 
#用字符串的方法来完成字符串的格式。
a = 321
b = 123
print('{0} * {1} = {2}'.format(a, b, a * b))
 
#方法二、更简洁的形式
a = 321
b = 123
print(f'{a} * {b} = {a * b}')
 
# %d 十进制整数； %s 字符串；   %f  浮点数；  %.nf  n表示保留的小数位数

变量值	占位符	格式化结果	说明
3.1415926	{:.2f}	'3.14'	保留小数点后两位
3.1415926	{:+.2f}	'+3.14'	带符号保留小数点后两位
-1	{:+.2f}	'-1.00'	带符号保留小数点后两位
3.1415926	{:.0f}	'3'	不带小数
123	{:0>10d}	0000000123	左边补0，补够10位
123	{:x<10d}	123xxxxxxx	右边补x ，补够10位
123	{:>10d}	' 123'	左边补空格，补够10位
123	{:<10d}	'123 '	右边补空格，补够10位
123456789	{:,}	'123,456,789'	逗号分隔格式
0.123	{:.2%}	'12.30%'	百分比格式
123456789	{:.2e}	'1.23e+08'	科学计数法格式

3.

# 字符串格式化——>str.format方法
 
# 省略字段名——大括号里省略字段名，传递位置参数；大括号个数可以少于未知参数的个数，但是多于会报错
print('我叫{},今年{}岁'.format('小明', 18))  # 我叫小明,今年18岁
print('武汉大学的优势学科有{},{}'.format('法学', '测绘', '哲学', '汉语言文学'))
# 武汉大学的优势学科有法学,测绘
 
# 数字字段名——>通过数字形式的简单字段名传递位置参数
'''数字必须是大于等于0的整数；带数字的替代字段可以重复使用
数字形式的简单字段名相当于把format中的所有位置参数当做一个元祖，
通过字段名中的数字进行取值。即{0}=tuple[0],所以大括号内的数字不能越界'''
# 通过数字形式的简单字段名传递位置参数
print('身高{0},家住{1}。'.format(1.78, '中南海'))  # 身高1.78,家住中南海。
# 数字形式的简单字段名可以重复使用
print('我爱{0},她今年{1}岁，{0}也爱我'.format('lx', 20))
# 我爱lx,她今年20岁，lx也爱我
 
# 变量字段名——使用变量名形式的简单字段名传递关键字参数，关键字参数的位置可以随意调换
# 使用变量名形式的简单字段名传递关键字参数
print('我大哥是{name}，今年{age}岁。'.format(name='阿飞', age=20))  # 我大哥是阿飞，今年20岁。
# 关键字参数的顺序可以随意调换
print('我大哥是{name}，今年{age}岁，'.format(age=20, name='阿飞'))  # 我大哥是阿飞，今年20岁。

Ps：在Python中，字符串是不可变的！所有的字符串相关方法，都不会改变原有字符串，都是返回一个结果，在这个新的返回值里，保留了执行后的结果——>字符串是不可变类型,不能通过索引

运算修改字符串中的字符

x = string[15:60:9]
print(id(string), id(x))  # id不同

三、控制结构

#随机数游戏
import random
computer=random.randint(1,6)
guess=int(input('请输入你的猜测结果:'))
if computer==guess:
    print('恭喜你猜对了')
else:
    print('对不起，你猜错了')
    print('正确答案是：',computer)

顺序结构

循环结构

for循环 

for 临时变量 in 序列:
    循环满足条件时执行的代码
序列——字符串、列表、元组、集合都可以；数字和布尔值不属于序列

for s in 'canjsbjh':
    print(s, end='-*-')
# 字符串的遍历——>  c-*-a-*-n-*-j-*-s-*-b-*-j-*-h-*-
print()
for s in 'cajh':  # 让for循环循环10次就需要in后面的字符串中有10个元素
    print('龙潜于渊，龙跃于天')
'''
龙潜于渊，龙跃于天
龙潜于渊，龙跃于天
龙潜于渊，龙跃于天
龙潜于渊，龙跃于天
'''

# for item in range(start,stop,step)  默认从start开始，到stop-1结束，step，即每次数值递增的值
 
# 用for循环打印1~100之间的数字的累积和
sum = 0
for item in range(1, 101):
    sum += item
    print("sum =", sum)
print("total_sum =", sum)
 
 
# for……else语句 —— 如果上面的for循环0~n-1没有出现中断(break),则在执行完for循环后执行else语句
for i in range(3):
    username = input("请输入用户名")
    password = input("请输入密码")
    if username == 'lx' and password == '123456':
        print('登陆成功')
        break
    print('用户名或者密码有误!\n')
else:
    print("账户被锁定")

while循环

while循环的格式
n = 0  # 初始化变量
while n <= 10:  # 循环条件的指定，True——>进入循环体
    print("龙潜于渊，龙跃于天")
    n += 2  # 改变变量/变量的自增或者自减
print("*" * 5)
 
# 打印1~50中可以被7整除的数字
n = 1
count = 0
while n <= 50:
    if n % 7 == 0:
        print('可以被7整除——→', n)
        count += 1
    n += 1
print('可以被7整除的有——→', count, '个')
print("*" * 5)
# 第二种方法
n = 0
while n <= 50 and n % 3 == 0:
    print("可以被7整除的有——→", n)
    n += 3
 
# 打印1~100之间的数字的累积和
n = 0
sum = 0
while n <= 100:
    sum += n
    n += 1
    print("n =", n, "sum =", sum)
print("sum =", sum)
print("*" * 5)
 
 
# while……else语句——else语句，不被中断则完成循环后执行else语句，被中断则不执行
n = 1
while n <= 10:
    print('n')
    n += 1
    if n == 5:
        break
else:
    print('over')

# while的嵌套语句
m=1
n=1
while m<=9:
    while n<=9:
        print('-*-'*n)
        n+=1
    m+=1
 
# while的嵌套语句
m=1
while m<=5:
    n=5
    while n>=m:
        print('-*-',end='')
        n-=1
    print()
    m+=1

Ps: for循环和while循环的区别

1. 确定次数循环和不确定次数循环

2.if语句只会执行一次判断条件，条件成立以后，只会执行一次代码块；而while语句，会先执行一次判断条件，如果条件成立，会执行一次代码块，代码块执行完成以后，会再次判断条件语句，如果还成立，将会再执行代码语句... 直到最后条件不成立。

break语句

格式实例
number = 0
while True:
    print('yeah')
    number += 1
    if number == 5:
        break  # 跳出当前的循环结构
 
# 最多输入用户名和密码三次，如果三次没有登陆成功，则提示账户被锁定
for i in range(3):
    username = input("请输入用户名")
    password = input("请输入密码")
    if username == 'lx' and password == '123456':
        print('登陆成功')
        break
    print('用户名或者密码有误!\n')
if i == 2:
    print("账户被锁定")
 
# 去超市购物，允许买多件东西，计算商品价格总额
total_money = 0
total_quantity = 0
while True:
    price = float(input('输入价格'))
    quantity = int(input('输入数量'))
    total_money += price * quantity
    total_quantity += quantity
    answer = input("total_money=%.2f,是否继续(y/n)")
    if answer == "n":
        break
print("total_quantity=%d,total_money=%.2f" % (total_quantity, total_money))
 
 
# 产生随机数，可以猜多次，直到猜对为止，如果猜错了，会给提示
import random
computer = random.randint(1, 10)
count_game = 0
while True:
    guess = int(input("请输入你猜测的数字："))
    count_game += 1
    if guess == computer:
        print("恭喜你猜对了")
        break
    elif computer >= guess:
        print("猜错了，请再猜大些")
    else:
        print("猜错了，请再猜小些")
print("你总计猜测了%d次" % count_game)
if count_game >= 5:
    print("运气一般啊，再接再厉")
else:
    print("运气太棒了，欧皇非你莫属")
    print('— * - ' * 5)

continue语句

for i in range(10):
    if i %3==0:
        continue
    print(i)
 
for i in range(10):
    if i%3!=0:
        print(i)
 
for i in range(10):
    if i %3==0:
        break
    print(i)
'''
break和continue的区别：
break和continue的位置都是出现在循环中的，只能用于循环语句中；break和continue在嵌套循环中使用时，只对最内层循环有效。
break是跳出循环结构；continue是跳出本次循环，继续下一次循环，但是未必退出循环结构
一般情况下，循环语句和else共同出现时，在循环语句里都会配合break语句来使用。只要循环没有顺利完成，中间被break中断了则else里面的内容就不会执行。
 
'''

选择结构/分支结构

if……elif……else模块

条件：运算符构成，布尔值类型

条件语句

if 条件1：

        条件1为True时执行的语句

elif 条件n:

        条件n为True时执行的语句

……

else:

        上述条件均不成立时的执行的语句

# 产生两个0~10的随机整数，判断两数之和是否大于8且两数之差小于3，如果是，显示：success，反之，显示“fail
import random
 
computer1 = random.randint(1, 10)
computer2 = random.randint(1, 10)
print("两个随机数字是,", computer1, computer2)
if (computer1 + computer2 > 8) and (computer1 - computer2 < 3 and computer2 - computer1 < 3):
    # abs(computer1 - computer2) < 3
    print('success')
else:
    print('fail')

'''
阿里巴巴商家节，用户名，消费总金额，账户金额，优惠券
输入购买总购买金额
如果金额0-500，则是lv1级别，随机赠送三张1~10元的优惠券；
如果500-2000元则是lv2，赠送2张50元优惠券，如果充值则送充值金额的10%，
2000元以上则是lv3，赠送2张100元优惠券，如果充值则送15%的金额
'''
user = "lx"
total = 1500  # 消费总金额
money = 0  # 账户金额
coupon = 0  # 优惠券
if 0 < total < 500:
    quan1 = random.randint(1, 10)
    quan2 = random.randint(1, 10)
    quan3 = random.randint(1, 10)
    coupon = quan1 + quan2 + quan3
 
elif 500 < total < 2000:
    coupon = 2 * 50
    recharge = input('是否充值，充值送充值金额的10%, y / n :\n')
    if recharge == "y":
        money += 1.1 * float(input("请输入充值金额(元):"))
 
elif total > 2000:
    coupon = 2 * 100
    recharge = input('是否充值，充值送充值金额的10%, y / n :\n')
    if recharge =='y':
        money += 1.15 * float(input("请输入充值金额(元):"))

if的嵌套循环

'''
默认username=admin，password=1234
是否记住密码bool类型，is_remember
如果用户名和密码正确，并且is_remember是True表示记住密码，则打印已经记住用户的密码，
否则打印 没有记住密码，需要下次继续输入
'''
username=input('admin')
password=input('1234')
is_remember==True
if username=='admin' and password=='1234':
    if is_remember:
        print('已经记住用户%s的密码了'%username)
    else:
        print('没有记住密码，需要下次继续输入')
else:
    print('用户名或者密码有误！')

'''
模拟超市付款：
1.键入商品单价、商品数量，计算应付总额
2.提示用户选择付款方式：现金支付无折扣、微信支付95折、刷卡满100减20、
'''
print('~~~~~~欢迎光临自强超市~~~~~')
price = float(input('商品单价：'))
number = int(input('商品数量：'))
total = price * number
choice = input('请选择付款方式：1.现金支付 2.微信支付 3.刷卡支付')
if choice == '1':
    print('现金支付没有折扣，应付金额是：%.2f' % total)
elif choice == '2':
    total = total * 0.95
    print('微信支付享有95折优惠,支付金额为：%.2f' % total)
elif choice == '3':
    if total > 100:
        total -= 20
        print('刷卡满100减20,支付金额为：%.2f' % total)
    else:
        print('消费未满100，无法享受优惠 ', total)
else:
    print('输入错误，请再次选择！')

if的知识补充

# if语句的区间比较
a = 10
print(9 < a <= 21)  # True
print(11 < a < 20)  # False
# 三元运算符
# 变量=value1 if 条件 else value2 当条件成立时，把value1的值赋给变量，否则将value2的值赋给变量
a=10
b=30
c=a if a>b else b
print('a和b两个数中的较大值是',c)
# 自动转换类型
'''if语句需要一个判断条件，这个判断条件的结果需要一个布尔值，
如果此时输入的判断条件不是一个布尔值，在代码执行的过程中，会将这个值自动转换成为一个布尔值'''
if 'hello':
    print('hello world!')
else:
    print('人生苦短，我学Python')
'''在Python中，只有空字符串''、“”、''''''、数字0，空字典{}，空列表[]，空元组()，
和空数据None会被转换成为False，其他的都会被转换成为True'''

对象

赋值语义

值语义

引用语义

四、列表

1、列表的特点：

①有序性

②一个索引对应一个列表元素，但是一个列表元素有两个索引

③列表可以储存任何类型的数据

④列表元素可以重复

2、列表的创建（列表名、赋值符号、列表元素）

         name=[value1,value2……];

         name=list()

        列表生成式（生成列表的公式）  

[ i*i     for i in range(start,stop,step)](表示列表元素的相关表达式、自定义变量、可迭代对象)

注意：=表示列表元素的表达式中通常包含自定义变量

3、列表的查询——判断列表中是否存在要查找的元素

获取列表中单个元素的索引

index()函数  如果列表存在多个相同元素，只返回相同元素的第一个元素索引；如果查询的元素在列表中不存在，则会抛出ValueError ; 还可以在指定的start和stop之间进行查找

正向索引  从0到N-1

逆向索引  从-N到-1

指定索引

判断指定元素是否在列表内  in/not in 

遍历（迭代）  for 迭代变量 in  列表名

'''list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
list.count(obj) 统计某个元素在列表中出现的次数
obj in list 其实这个在前面说过，但是也可以用于判断'''
 
heros = ['探险家','河流之王','冰晶凤凰','荒漠屠夫','齐天大圣','冰晶凤凰','赛恩','冰晶凤凰']
# 判断'荒漠屠夫'是否在列表中存在
n = heros.index('荒漠屠夫')
print(n)  # 3
 
# 判断'牛头酋长'是否在列表中存在
n = heros.index('牛头酋长') 
print(n)
# 查找的元素不在列表中，会报错的，ValueError: '牛头酋长' is not in list。
 
# 也可以使用count判断个数
n = heros.count('冰晶凤凰')
print(n)  # 3
 
# 当然也可以使用：'荒漠屠夫' in heros
print('荒漠屠夫' in heros)  # True
 
 

4、列表的切片——获取列表中的多个元素——切片返回的是一个列表，可以理解为“子列表”。

[start,stop,step]

start和stop是左闭右开的区间，step表示的是步长，并且步长可以是正向（从左向右）也可以是逆向（从右向左）取元素。step如果是负数表示的是逆向，如果是正数表示的是正向。

如果stop省略则表示到列表最后一个元素，如果start省略表示从第一个元素开始

5.列表的运算

5、列表的修改

增加操作

append()  在列表的末尾添加一个元素

extend()   在列表的末尾至少添加一个元素

insert()      在列表的任意位置添加一个元素        list.insert(index,value)

切片          在列表的任意位置添加元素，该位置之后的元素会被替代

list = [10, 20, 30]
print('添加元素之前', type(list))  # 添加元素之前 <class 'list'>
list.append(100)
print('添加元素后', list, type(list))  # 添加元素后 [10, 20, 30, 100] <class 'list'>
list[2:] = [80, 90]
print('第二次修改之后', list)  # 第二次修改之后 [10, 20, 80, 90]
list[4:] = [110, 130]
print('第三次修改之后', list)  # 第三次修改之后 [10, 20, 80, 90, 80, 90]
# 切片的起始位置之后的所有列表元素会被切片赋值的元素所替代
 
list1 = [22, 44, 55, 88]
list2 = [33, 66, 99]
list.extend(list2)
print(list)  # [10, 20, 80, 90, 110, 130, 33, 66, 99]
 

删除操作

remove() 一次删除一个；重复元素只删除第一个；元素不存在则抛出异常

pop()  删除一个指定索引位置上的元素；指定索引不存在抛出IndexError ; 不指定索引，删除列表中的最后一个元素

clear()清空列表

del()删除列表

切片一次至少删除一个元素

heros = ['探险家','河流之王','荒漠屠夫','齐天大圣','冰晶凤凰','赛恩','冰晶凤凰']
# 删除下标为1的元素
del heros[1]
print(heros) 
# 删除下标为1的元素，并获取返回值
element = heros.pop(1)
print(heros) 
print(element)
# 删除：'冰晶凤凰'
element = heros.remove('冰晶凤凰')
print(heros)
print(element)
# 注意这句话会报错的，ValueError: list.remove(x): x not in list
element = heros.remove('冰晶凤凰1')
print(heros)
'''可以看到remove的返回值是None，而且是只删除了从左向右的第一个遇到的元素，后面的没有删除。而且如果要删除的元素不在列表中存在则会报异常：ValueError。'''
 
['探险家', '荒漠屠夫', '齐天大圣', '冰晶凤凰', '赛恩','冰晶凤凰']
 
['探险家', '齐天大圣', '冰晶凤凰', '赛恩','冰晶凤凰']
 
荒漠屠夫
 
['探险家', '齐天大圣', '赛恩','冰晶凤凰']
 
None

列表数值的修改

一次修改一个值        list[index]=value

一次修改多个值       list[start,stop,step]=[value1,value2,value3...]

6、列表的排序

指定关键字参数

reverse=False  升序排列

reverse=True 降序排序

调用sort() 方法，列表中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True,进行降序排序

调用内置函数sorted() 可以指定reverse=True 进行降序排序，愿列表不发生改变

heros = ['探险家','河流之王','冰晶凤凰','荒漠屠夫','齐天大圣','冰晶凤凰','赛恩','冰晶凤凰']
# 倒序列表中的元素
heros.reverse()
print(heros)
# ['冰晶凤凰', '赛恩', '冰晶凤凰', '齐天大圣', '荒漠屠夫', '冰晶凤凰', '河流之王', '探险家']
 
# 对列表中的元素进行排序
heros.sort()
print(heros)
# ['冰晶凤凰', '冰晶凤凰', '冰晶凤凰', '探险家', '河流之王', '荒漠屠夫', '赛恩', '齐天大圣']
 
# 对列表中的元素进行排序，也可以降序
heros.sort(reverse=True)
print(heros)
# ['齐天大圣', '赛恩', '荒漠屠夫', '河流之王', '探险家', '冰晶凤凰', '冰晶凤凰', '冰晶凤凰']
 
 
 
 

五、元组

六、字典

七、递归

        递归的组成部分

                        递归调用

                        递归终止条件

        递归调用过程

每递归调用一次函数，都会在栈内存分配一个栈帧；每执行完一次函数，都会释放相应的空间

        递归的优缺点

                缺点：占用内存多，效率低下

                优点：思路和代码简单

八、文件处理

        文件

        文件扩展名

        文件格式

                 .mp4

                .mp3

                .txt.

                .md

        文件路径

九、库的调用

        标准库

        第三方库

        import keyword

        print(keyword.kwlist)