《《python基础》》

      - 创始人: Guido van Rossum（荷兰人）。

       ![guido](./images/guido.jpg)

  - 时间 : 1989年圣诞节期间

     - 地点 : 阿姆斯特丹

  - Python命名: 源于Guido 是一个喜剧团 Monty Python 的粉丝。

python 的应用领域

  - 自动化系统运维

  - 自动化测试

  - 人工智能，机器人

  - 搜索引擎，爬虫

  - 科学计算

  - web网站后端开发

  - 云计算

  - 大数据及数据库编程

  - 游戏

  - 其它

python 的优缺点

1) 优点

           高级：有高级的数据结构，缩短开发时间与代码量

           面向对象：为数据和逻辑相分离的结构化和过程化编程添加了新的活力

         可升级：提供了基本的开发模块，可以在它上面开发软件，实现代码的重用

           可扩展：通过将其分离为多个文件或模块加以组织管理

           可移植性：python是用 C 语言写的，又由于 C 的可移植性，使得 Python 可以运行在任何带有 ANSI C编译器的平台上；

             易学：python 关键字少、结构简单、语法清晰；

             易读：没有其他语言通常用来访问变量、定义代码块和进行模块匹配的命令式符号；

             内存管理器：内存管理是由python解释器负责的；（软件工程化思路）

  2.)缺点

             - 与C/C++相比，执行速度不够快

             - 不能封闭源代码

              c语言执行能力高，python执行能力底但开发效率高

python 的官网

  - 网址: <https://www.python.org>

    世界计算语言排名网站:   www.tiobe.com

  - 我们可以通过官网得到更多更新的信息及文档。

python 的版本

  - Python V2.7(2020年已经结束维护)

  - Python V3.6(当前教学)

  - Python V3.9(最新)

python的官方文档

https://docs.python.org/zh-cn/3/

Python起步

第一个Python程序

1)编写一个 hello.py

2)写入内容
print('hello world!')
3)Python的解释执行器执行 hello.py
# Linux下
$ /usr/bin/python3 ~/桌面/hello.py 

# Windows 下
C:\> python hello.py

python 的两种运行模式

1)使用文件解释执行模式

先将 python 的语句。写入xxx.py当中。然后用python3 命令解释执行该文件
$ python3 xxx.py
2)交互模式

在命令提示符下直接输入python3命令进入交互模式。

调用exit() 退出交互模式
 # Linux 下进入交互模式
  $ python3  <回车>
  >>> # 在此处可以输入 语句和表达式(回车执行)
  >>> exit()  # 退出交互模式，回到终端
使用文件解释执行方式示例
 [root@localhost day01]# cat hello.py 
  print('Hello World!')
  [root@localhost day01]# python3 hello.py 
  Hello World!

Python 的基本输入输出

1)Python 的输出函数

        print() 函数

作用:

        向终端输出文字信息，能让用户看到

                当有多个数据要输出时，中间用英文的逗号(,) 分隔开

调用格式
print(数据1, 数据2, 数据3, ..., sep=' ', end='\n')
在python中主要使用print实现输出，print是一个函数

在python中函数调用需要添加()，括号内是传给函数的参数
print("hello world!")
print("年龄是", 35)
print(1, 2, 3, 4)
print(1, 2, 3, 4, sep=" ", end="\n")
print(1, 2, 3, 4, sep="###", end="\n\n\n")
print(1, 2, 3, 4)

Python的基本输入函数

input 函数

作用

让程序停下来，等待用户输入文字信息，返回用户输入文字的字符串

调用格式
input("提示信息")
示例
name = input('请输入您的姓名:')
python中，通过input函数获取用户键盘输入

input函数的参数是字符串，它是屏幕提示语

注释

注释以井号（#）开头，在物理行末尾截止。

PyCharm的使用

PyCharm 下快捷键

ctrl + s 保存

ctrl + / 注释和取消注释

ctrl + d 可以复制当前行到下一行

ctrl + alt + L 可以将程序自动格式化成符合PEP8 编码规范的格式

PyCharm 的调试

1. 设置断点
2. 单步执行

变量和赋值语句

赋值语句

作用

创建一个自定义名字的变量，此变量可以用于绑定一个表达式执行的结果，供后续使用

语法
变量名 = 表达式
变量名1 = 变量名2 = 变量名3  = 表达式
变量名1, 变量名2, 变量名3  = 表达式1, 表达式2, 表达式3
示例
one_hundred = 99 + 1
a = b = c = 200
a, b = 100, 200
说明

       - 第一次为变量赋值，python 会创建变量，同时绑定表达式执行的结果

       - 第二次或者以后为变量赋值，会改变原有变量的绑定关系

       - python 的变量没有类型，它绑定的对象才有类型

       - 变量在使用之前，必须先进行赋值

       - 变量赋值是一个自右向左的运算，将=右边表达式的计算结果，赋值给左边的变量

变量

变量是在python 内用赋值语句创建，用来绑定一个数据的有名对象

变量名

        变量名必须是一个标识符

标识符的命名规则

        -第一个字母必须是英文字母或下划线 [ A-Za-z_ ]

        -从第二个字母起(如果有),必须是英文字母或下划线或数字

                [ A-Za-z0-9_ ]

                变量名称约定

        -变量名区分大小写

示例

        以下是合法的标识符
a        a1           abc       ABC     a1b2c3d4
one_hundred          count      _a      __ABC__
getNameAge         get_name_age        GetNameAge
# 小驼峰              匈牙利命名法         大驼峰
        python 编程语言中的关键字不能作为标识符

推荐采用的命名方法

        -变量名全部采用小写字母，如pythonstring

        -简短、有意义，如pystr

        -多个单词间用下划线分隔，如py_str

        -变量名用名词，函数名用谓词（动词+名词），如 phone / update_phone

        -类名采用驼峰形式，如MyClass

关键字(keywords)

        计算机编程语言中保留的标识符称为关键字, 关键字不能当成普通的标识符使用

              关键字通常用于语法标识

          python3.9中的全部的关键字
False      await      else       import     pass
None       break      except     in         raise
True       class      finally    is         return
and        continue   for        lambda     try
as         def        from       nonlocal   while
assert     del        global     not        with
async      elif       if         or         yield
示例
>>> a = 10 + 5  # 第一次为变量赋值是创建变量
>>> a
15
>>> a = 100  # 再次为变量赋值，会改变已经存在的变量.
练习
写一个程序 myprog.py
# 1. 让用户输入用户名
# 2. 让用户输入密码
# 3. 打印 谁谁谁 的密码是 xxx
答案:
name = input("请输入您的姓名： ")

password = input("请输入您的密码： ")

print(name, '的密码是：', password)

Python 的基础数据类型

数据类型

字符串 str

数字

整数 int

浮点数 float

布尔数 bool

容器

列表 list

元组 tuple

字典 dict

集合 set / 固定集合 frozenset

字节串 bytes / 字节数组 bytearray
示例字符串 str与数字

住址: 字符串

邮编: 数字(也可以用字符串)

门牌号: 整数

字符串

程序中,用来记录人类的文字信息的一种数据类型

创建字符串的字面值
# 用 英文的 ' 或 " 或 ''' 或 """  开始或结束
# 此示例示意字符串的写法
print('同学们好')
print("同学们好")
print('''同学们好''')
print("""同学们好""")
说明

-双引号的字符串的内部的单引号不算是结束符

-单引号的字符串的内部的双引号不算是结束符
# I'm a teacher!
print("I'm a teacher!")
# 我是"kali_yao"
print('我是"kali_yao"')
-三引号字符串的内部可以包含单引号和双引号
# I'm a teacher! 我是"kali_yao"
print('''I'm a teacher! 我是"kali_yao"''')
-三引号字符串又称为所见即所得字符串, 每一次换行会转换成换行符 '\n'
# print("咏鹅\n鹅鹅鹅,\n曲项向天歌;\n白毛浮绿水，\n红掌拨清波。")
# 等同于如下写法
print('''咏鹅 
鹅鹅鹅,
曲项向天歌;
白毛浮绿水，
红掌拨清波。''')
字符串的转义

字符串的字面值中，可以加反斜杠 \ 后加一个或多个字符串，代表一个单个的字符
\'    代表一个单引号
\"    代表一个双引号
\n    代表一个换行符
\\    代表一个反斜杠
思考
思考
我是单引号',我是双引号", 我是三单引号''', 我是三双引"""
# 解决方法
print('我是单引号\',我是双引号\", 我是三单引号\'\'\', 我是三双引"""')
Python 中全部的转义字符串
转义序列    含义    注释
\newline    反斜杠加换行全被忽略    
\\    反斜杠 (\)    
\'    单引号 (')    
\"    双引号 (")    
\a    ASCII 响铃 (BEL)    
\b    ASCII 退格 (BS)    
\f    ASCII 进纸 (FF)    
\n    ASCII 换行 (LF)    
\r    ASCII 回车 (CR)    
\t    ASCII 水平制表 (TAB)    
\v    ASCII 垂直制表 (VT)    
\ooo    八进制数 ooo 码位的字符    (1,3)
\xhh    十六进制数 hh 码位的字符    (2,3)
练习:
# 写程序，打印如下文本内容
print("hello world")
答案
>>> print('print("hello world")')
print("hello world")
>>> 
>>> print("print(\"hello world\")")
print("hello world")
字符串的基本运算

+ 号运算符, 用于拼接字符串(生成新的字符串)

+ 号的两侧都必须是字符串
'今天是' + '7月13日'  # 生成 '今天是7月13日'
s1 = '123'
s2 = "456"
s3 = s1 + s2
print(s1)   # 123
print(s2)   # 456
print(s3)   # 123456
* 运算, 用于生成重复的字符串

字符串只能和整数相乘
print('我想你了' * 100)

数字

Python 中的基本的数字类型
整数 int
浮点数(小数)  float
布尔类型数 bool
-整数 int

整数的字面值
# 十进制的写法
100        0         -5

# 二进制的写法 0b 开头 后跟 0~1
0b1101

# 八进制的写法 0o开头 后跟 0~7
0o777   等于  0b111111111   等于 511

# 十六进制的写法  0x 开头 后跟 0~9, a-f, A-F
0xA1B2C3D4
-浮点数(小数) float

浮点数的字面值
# 小数写法
3.14         0.14       .14         3.0       3.      0.0
# 科学计数法
6.18E-1   # 等同于 0.618   
2.9979E8   # 等同于 299790000.0
        -布尔类型的数 bool

                True    真(表示行，好，成立)                值为1

                False   假(表示不行，不好，不成立)    值为0

算术运算符

+      加法
-      减法
*      乘法
/      除法
//     地板除法(向下取整)   floordiv
%      求余数
**     幂运算(也叫乘方运算)  x ** y 代表 x 的 y 次方

示例

>>> 1 + 2 * 3 / 4
2.5
>>> 14 / 3 
4.666666666666667
>>> 14 // 3
4
>>> 14 % 3
2
>>> 3 ** 2
9

比较运算符

比较运算符是二元运算符

运算符

<    小于
<=   小于等于
>    大于
>=   大于等于
==   等于
!=   不等于

比较运算符通常返回布尔类型的数, True, False

>>> 100 + 200 > 3
True
>>> 1 + 3 >= 2
True
>>> 1 + 3 >= 200  # 表达式
False
>>> score = 83    # 这是赋值语句
>>> 60 <= score <= 100
True
>>> score = 59
>>> 60 <= score <= 100
False

表达式和语句

表达式和语句的概念

表达式

        是由数字，字符串(文字), 运算符，函数调用等组成，通常用于计算并得到一个结果

                 表达式是语文中的字或短语

语句

        语句是计算机执行程序的最小单位

示例
a = 100      # 赋值语句
print(a)     # 表达式语句
函数调用是表达式
input('xxxx')  返回字符串

print("xxxx")   返回 None
函数调用语法规则
函数名(传入的参数)
None 是表示空值的一个对象

数据类型转换相关的函数
函数	说明
str(x)	把传入的x 转化成字符串并返回
int(x)	把 x 转化为整数并返回
float(x)	把 x 转化为浮点数并返回
bool(x)	把 x 转化为布尔类型的数并返回
示例:
>>> age = input('请输入年龄: ')  # 输入 35
>>> int(age)
35
>>> int("35")
35
>>> int(3.14)
3
>>> int('3.14')  # 报错
>>> f = 3.14
>>> str(f)
'3.14'
>>> int(f)
3
>>> bool(f)
True
python 中假值对象
None
False
0
0.0
''
[]   # 空列表
{}   # 空字典
...

布尔运算符(也叫逻辑运算符)

运算符
and    与运算
or     或运算
not    非运算
and 与运算

两者（两个元素同时为真，结果才为真）

语法
x and y   # x, y代表表达式
示例
>>> 3 + 4 > 5 and 6 + 7 > 100
真值表
x的值	y的值	x and y的值
True	True	True
True	False	False
False	True	False
优先返回假值对象, 如果x 为假值，返回x, 否则返回y

or 或运算

两者（两个元素只要有一个为真，结果就为真）
x or y   # x, y代表表达式
真值表
x的值	y的值	x or y的值
True	True	True
True	False	True
False	True	True
False	False	False
优先返回真值对象, 如果x 为真值，返回x, 否则返回y

not 非运算

not 运算符是一元运算符

语法
not 表达式
示例
not True    # False
not False   # True
not 3.14    # False
not ''      # True
not 1 + 2   # False
and 示例
>>> True and True    # True
>>> True and False   # False
>>> False and True   # False
>>> False and False  # False
>>> True or True    # True
>>> True or False   # Ture
>>> False or True   # Ture
>>> False or False  # False
>>> not False       # True
>>> not True        # Flase
>>> 3.14 and 5      # 5
>>> 0.0 and 5       # 0.0
>>> 3.14 or 5       # 3.14
>>> 0.0 or 0        # 0
>>> not 3.14        # False
>>> not 0.0         # True

if 语句

作用

让程序根据条件选择性的执行其中的某一个语句块

语法
if 条件表达式1:
    语句块1
elif 条件表达式2:
    语句块2
elif 条件表达式3:
    语句块3
...
elif 条件表达式n:
    语句块n
else:
    语句块(其他)
说明

        -elif 子句可以有0个，1个或多个,

       -else 子句可以有0个或1个且只能放在最后

       -它通过对表达式逐个求值直至找到一个真值（请参阅布尔运算了解真值与假值的定义）在子句体中选择唯一匹配的一个；然后执行该子句体（而且 if 语句的其他部分不会被执行或求值）。如果所有表达式均为假值，则如果 else 子句体如果存在就会被执行。

if 语句也是语句，他可以嵌套到其他的复合语句中
if xxxx:
     if yyyy > 0:
          print('.....')
     else:
          print("fjdsfdf")
else:
    print("hello")

del 语句

作用:

用于删除变量，同时解除与对象的关联，如果可能则释放此变量绑定的对象

语法:
del 变量名
del 变量名1, 变量名2, ...
自动化内存管理和引用计数:
每个对象都会记录有几个变量引用自身，当引用的数量为0时则此对象被销毁，此种自动化内存管理的方式叫做引用计数。

pass 语句

作用

用来填充语法空白

语法

pass

示例

# 如果 成绩在 0~100 什么都不做, 其他提示"您的输入有误"
score = int(input('请输入成绩:'))
if 0 <= score <= 100:
    pass
else:
    print('您的输入有误!')

条件表达式

语法
表达式x if 条件表达式C else  表达式y
说明

        执行顺序

                先判断条件表达式C 是真值还是假值，

                如果 C是真值，则表达式x 执行并返回结果

                如果 C是假值，则表达式y 执行并返回结果

表达式 x if C else y 首先是对条件 C 而非 x 求值。如果 C 为真，x 将被求值并返回其值；否则将对 y 求值并返回其值。

示例
>>> score = 69
>>> "及格" if 60 <= score <= 100 else "不及格"
'及格'
>>> s = "及格" if 60 <= score <= 100 else "不及格"
>>> print(s)
及格

字符串

字符串的概述及基本运用

字面值
'hello'    "hello"     '''hello'''    """hello"""
字符串转义
\'     代表一个单个的 '
\n
字符串的运算

+ 用于拼接字符串

* 用于生成重复的字符串

原始字符串(raw 字符串)

以字符r开头的字符串, 其中的 \ 不算转义字符串

字面值格式
r'字符串内容'
r"字符串内容"
r'''字符串内容'''
r"""字符串内容"""
in / not in 运算符

作用

in 用于序列，字符串，字典中，用于判断某个值是否存在于容器中,如果存在就返回True, 否则返回False

not in 的返回值与 in 相反

示例
>>> s = 'welcome to beijing!'
>>> 'to' in s
True
>>> 'weimingze' in s
False
>>> 'beijing' not in s
False
>>> 'weimz' not in s
True
字符串的索引 index

语法
字符串[整数表达式]
作用

        用来获取字符串其中的一个字符

说明

        正向索引: 字符串的正向索引是从0开始的，.... 最后一个索引为 len(s)-1

        反向索引: 字符串的反向索引是从 -1 开始的，-1 代表最后一个，... -len(s) 代表第一个

示例
>>> s = 'ABCDE'
>>> s[1]
B
>>> s[1+2]
D
>>> s[-1]
E
注: len(x) 函数可以求取一个字符串的长度

字符串的切片 slice

作用

从字符串序列中取出相应位置的元素，重新组成一个新的字符串

语法
字符串[(开始索引b):(结束索引e)(:(步长s))]
注: () 括起来的内容代表可以省略

说明

        -开始索引b是切片切下的开始位置

        -结束索引e 是切片的终止位置(但不包含终止点)

        -步长是切片取出数据后向后移动的方向和偏移量

               - 没有步长，相当于步长为1(默认为1)

               - 当步长为正数时，取正向切片

                       - 开始索引默认为0, 结束索引是最后一个元素的下一个索引

               - 当步长为负数时，取反向切片

                       - 开始索引默认为-1, 结束索引是第一个元素的前一个索引

示例
  #   01234
>>> s = 'ABCDE'
>>> s[1:]    # 'BCDE'
>>> s[-2:]   # 'DE'
>>> s[1:4]   # 'BCD'
>>> s[:]     # 'ABCDE'
>>> s[:2]    # 'AB'
>>> s[1:1]   # ''
>>> s[4:2]   # ''
>>> s[::]    # 等同于 s[::1] 'ABCDE'
>>> s[::2]   # 'ACE'
>>> s[2::2]  # 'CE'
>>> s[-1::-2] # 'ECA'
>>> s[::-1]   # 'EDCBA'

符串的格式化表达式

作用

生成具有一定格式的字符串

语法规则

格式化字符串 % 参数1
# 或者
格式化字符串 % (参数1， 参数2, 参数3)

占位符和类型码

占位符和类型码	说明
%s	转成字符串, 使用 str(x) 函数转换(常用)
%d	转成 十进制的整数(常用)
%o	转成 八进制的整数
%x,%X	转成 十六进制的整数
%e,%E	转成 指数格式的浮点数
%f,%F	转成小数格式的浮点数(常用)
%g,%G	转成指数格式或小数格式的浮点数
%%	转成一个%

示例1

>>> fmt = """
甲方:_____%s_____
乙方:_____%s_____
   ....... 金额:_%d__
"""
>>> s = fmt % ("kali", 'yao', 10000)
>>> print(s)

甲方:_____kali_____
乙方:_____yao_____
   ....... 金额:_10000__

示例2

>>> "+++%d+++" % 999    # 返回 '+++999+++'
'+++999+++'
>>> "+++%s+++" % 3.14
'+++3.14+++'
>>> "+++%s+++" % "weimz"
'+++weimz+++'
>>> "+++%d+++" % 3.1415
'+++3+++'
>>> "+++%d+++" % 13
'+++13+++'
>>> "+++%o+++" % 13
'+++15+++'
>>> "+++%x+++" % 13
'+++d+++'
>>> "+++%e+++" % 3.1415
'+++3.141500e+00+++'
>>> "+++%f+++" % 3.1415
'+++3.141500+++'
>>> "+++%g+++" % 3.1415
'+++3.1415+++'
>>> "+++%g+++" % 3141523274812374281342374324.23748123742183472
'+++3.14152e+27+++'

占位符和类型码之间的格式化语法

% [- + 0 宽度.精度] 类型码

- 左对齐
+ 显示正号
0 左侧空白位置补零
宽度：整个数据输出的宽度
精度: 保留小数点以后多少位(默认小数点以后保留6位)
常用于 %d 和 %f 中

示例

>>> "--%d--" % 99
'--99--'
>>> "--%5d--" % 99
'--   99--'
>>> "--%05d--" % 99
'--00099--'
>>> "--%5d--" % 99
'--   99--'
>>> "--%+5d--" % 99
'--  +99--'
>>> "--%-5d--"  % 99
'--99   --'
>>> "--%f--" % 3.1415926
'--3.141593--'
>>> "--%.2f--" % 3.1415926
'--3.14--'
>>> "--%7.2f--" % 3.1415926
'--   3.14--'

字符串的常用方法(method)

方法的调用语法

对象.方法名(参数)

示例:

>>> "abc".isalpha() 
True
>>> "123".isalpha()
False
>>> "123".isdigit()
True

. 是"的"的意思

字符串的常用方法

方法名（S代表字符串对象）	说明
S.isalpha()	判断字符串是否是英文字符
S.isdigit()	判断字符串是否是全为数字
S.isupper()	判断字符串是否是全为大写的英文字符
S.islower()	判断字符串是否是全为小写的英文字符
S.center(width[, fill])	将字符串按width 宽度居中，左右默认填充空格
S.count(sub[, start[, end]])	获取字符串中的子串的个数
S.startswith(prefix)	返回S是否以prefix 开头
S.endswith(suffic)	返回S是否以suffic结尾
str.replace(old, new[, count])	替换字符串
str.find(sub[, start[, end]])	查找字符串,返回第一次出现的索引，如果没找到，返回-1
str.index(sub[, start[, end]])	查找字符串,返回第一次出现的索引,如果没找到则报错
str.rindex(sub[, start[, end]])

代表其中的内容弄可以省略

详见： https://docs.python.org/zh-cn/3/library/stdtypes.html#string-methods

示例:

>>> s = "ABC"
>>> s.center(10)
'   ABC    '
>>> s.center(10, '#')
'###ABC####'
>>> s = 'hello world, hello china'
>>> s.count('hello')
2
>>> s.count('hello', 10)
1
>>> s.count('hello', 10, 12)
0
>>> s = "/root/music/冰雨.mp3"
>>> s.startswith('/root/')
True
>>> s.endswith('.mp3')
True
>>> s.endswith('music')
False
>>> s = 'welcome to Beijing'
>>> s.upper()
'WELCOME TO BEIJING'
>>> s.lower()
'welcome to beijing'
>>> s.title()
'Welcome To Beijing'

>>> s = '/root/music/冰雨.mp3'
>>> pos = s.rindex('/')
>>> pos
11
>>> pathname= s[:pos]
>>> filename = s[pos+1:]
>>> print(pathname)
/root/music

while 语句

作用

根据一定的条件，重复的执行某个语句块

语法
while 真值表达式:
    语句块1  (*此部分可能会重复执行)
else:
    语句块2
说明

        -else 子句可以省略

        -else 子句当且仅当真值表达式为假Flase的时候会执行 else 里的语句块2

        -如果此 while 是因为调用 break 语句而终止循环。则 else 子句里的语句不会执行

示例1
while 1 < 2:
    print("hello world")
示例2
# 打印 5 行 "hello world"
i = 0
while i < 5:
    print("hello world")
    i = i + 1  # 也可写成 i += 1
else:
    print("while 语句已经结束!")

语句嵌套

while 语句也是语句, 和其他的语句一样，可以嵌套到其他的任何复合语句中。

while 语句嵌套示意:
while 真值表达式:
    ...
    while 真值表达式2:
        ...
    else:
        ...
    ......
else:
    ...

break 语句

作用

用于循环语句(while, for语句)中, 当break 执行是，她会终止包含他的当前循环。

语法
break
说明

        break 语句只能用在 while 语句或for语句的内部.

        break 语句通常和 if 语句组合使用.

        当break 语句执行后，此循环语句break 之后的所有语句都不会执行（else 子句里的语句也不执行）

        break 语句只能终止包含他的当前循环，当有循环嵌套时，只能跳出离他最近的一个循环

示例
i = 1
while i <= 5:
	print('i=', i)
    if i == 2
        break
	i += 1
else:
    print('循环结束: i=', i)
死循环

        死循环是指循环条件一直成立的循环

        死循环通常使用 break 语句来终止循环

        死循环的 else 子句中的语句永远不会执行

写法
while True:
    语句块
循环通常用户循环次数无法确定的循环

for 语句

作用

        用来遍历可迭代对象的数据元素

遍历是指经历且只经历一遍

可迭代对象是指能够依次获取数据元素的对象

可迭代对象

        字符串

        ---- 以下后面才讲----

        列表 list

        字典 dict

        ...

语法
for 变量列表 in 可迭代对象:
    语句块1
else:
    语句块2
语法说明

        else 子句可以省略

        else 子句的语句块2 只有在可迭代对象不再能提供数据的时候才会执行

        因为语句块1 部分调用break 而终止循环式，else 子句部分不会执行

示例
s = 'ABCDE'
for ch in s:
    print('ch=', ch)
else:
    print("遍历结束")

range 函数

作用

用来生成一个能够得到一系列整数的可迭代对象（也叫整数序列生成器）

调用格式
range(stop)                 # stop 停止整数
range(start, stop)          # start 开始整数
range(start, stop, step)    # step 步长
range 函数调用会生成从 start 开始，到 stop 结束(不包含stop) 的一系列整数，整数的间隔 step

start 默认值为0, step 默认值为1

示意
range(4)          # 生成 0 1 2 3
range(3, 6)       # 生成 3 4 5
range(1, 10, 2)   # 生成 1 3 5 7 9
range(5, 0, -2)   # 生成 5 3 1
示例
>>> for x in range(4):
...     print(x)
... 
0
1
2
3
>>> for x in range(3, 6):
...     print(x)
... 
3
4
5
>>> for x in range(1, 10, 2):
...      print(x)
... 
1
3
5
7
9
>>> for x in range(5, 0, -2):
...     print(x)
... 

continue 语句

作用

用于循环语句(while 语句和for语句)中，不再执行本次循环内 continue 之后的语句，开始一次新的循环

语法
continue
说明

在for 语句中, 执行continue 语句，for语句将会从可迭代对象向中获取下一个元素绑定变量后再次进行循环

在while 中,执行continue 语句, 将会直接跳转到while 语句的真值表达式处，重新判断循环条件

示例1
for x in range(5):
    if x % 2 == 0:
        continue
    print(x)    # 0 1 2 3 4
示例2
x = 0
while x < 5:
    print(x)
    x += 1
值
None
复合赋值分隔符
x += y    # 等同于 x = x + y
x -= y    # 等同于 x = x - y
x *= y    # 等同于 x = x * y
x /= y    # 等同于 x = x / y
x //= y   # 等同于 x = x // y
x %= y    # 等同于 x = x % y
....

容器

列表 list

列表是一种可以存储任意个各种类型的序列容器

列表内的数据有先后顺序关系

列表是可变的容器

序列指有序排列

python 中默认有4种可变的容器

列表list

字典 dict

集合 set

字节数组 bytearray

python 3 中的序列

字符串 str

列表 list

元组 tuple

创建列表的字面值

>>> L = []     # 创建一个空的列表
>>> L = ['北京', '上海', '广州', '西安']  # 创建一个含有4个字符串的列表
>>> L = [1, 'Two', 3.14, True, False, None]
>>> L = [1, 2, [3.1, 3.2], 4]   #  含有四个元素的列表，第三个元素是列表
>>> L2 = [
	['姓名','语文成绩','数学成绩'],
	['小明', 90, 100],
	['小新', 59, 26]
]

注： python 中的 (), [], {} 和三引号字符串都要成对出现, 可以换行

创建列表的构造函数 list

L = list()          # L = []
L = list("ABC")     # L = ['A', 'B', 'C']
L = list(range(5))  # L = [0, 1, 2, 3, 4]

列表的运算

列表list同字符串str都是序列, 他们的运算规则基本相同

+ 用于拼接列表

>>> [1, 2, 3] + [4, 5, 6]   # [1, 2, 3, 4, 5, 6]

+= 追加

语法列表 += 可迭代对象

>>> L = [1, 2, 3]
>>> L += [4, 5]         # L = [1, 2, 3, 4, 5]
>>> L = [1, 2, 3]
>>> L += "ABC"          # L = [1, 2, 3, 'A', 'B', 'C']
>>> L += range(2)

* 用于生产重复的列表

>>> [1, 2] * 3    # [1, 2, 1, 2, 1, 2]
>>> L = [5, 6]
>>> L *= 3        # L = [5, 6, 5, 6, 5, 6]

== != 用于比较

列表[整数表达式]

>>> [1, 2, 3] == [1, 2, 3]    # True
>>> [1, 2, 3] != [3, 2, 1]    # True

in /not in 用于判断一个数据元素是否在列表中

>>> "hello" in [1, "hello", 'world']
True
>>> '红楼梦'  in ['三国演义', '西游记']
False

索引

列表[整数表达式]

L = [1, 2, 3, 4, 5, 6]
print(L[0])    # 1
print(L[-1])   # 6

切片

列表[(开始索引b):(终止索引e)(: (步长s))]

() 里的内容代表可以省略

x = [1, 2, 3, 4, 5, 6, 7, 8]
y1 = x[:4]     # y1 = [1, 2, 3, 4]
y2 = x[::2]    # y2 = [1, 3, 5, 7]
y3 = x[::-1]   # y3 = [8, 7, 6, 5, 4, 3, 2, 1]

列表是可变的容器(不同于字符串)

列表是可变的

字符串是不可变的

>>> L1 = L2 = [1, 2, 3]
>>> L1 += [4, 5, 6]  # L1 = [1, 2, 3, 4, 5, 6]
>>> L2 
[1, 2, 3, 4, 5, 6]
# 不同于字符串
>>> s1 = s2 = "ABC"
>>> s1 += 'DEF'    # s1 = 'ABCDEF'
>>> s2 
'ABC'

列表的数据操作(增、删、改、查)

添加数据

方法

方法名(L代表列表)	说明
L.append(x)	向列表的末尾追加单个数据
L.insert(index, obj)	将某个数据obj 插入到 index这个索引位置的数据之前
L.extend(可迭代对象)	等同于: L += 可迭代对象

示例

mylist1 = [1, 3, 4]            # 目标是变成 [1, 2, 3, 4, 5]
mylist1.append(5)               # mylist1 = [1, 3, 4, 5]
mylist1.insert(1, 2)            # mylist1 = [1, 2, 3, 4, 5]
mylist1.extend(range(6, 10))    # mylist1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]

修改数据(改)

用索引赋值可以改变列表内的数据

列表[整数表达式] = 表达式

示例

mylist2 = [1, 1.99, 3]   # 把1.99 改为2
mylist2[1] = 2    # mylist2 = [1, 2, 3]

删除数据(删)

方法

方法	说明
L.remove(x)	从列表L中删除第一次出现在列表中的数据元素，如果x不存在则报错
L.clear()	清空列表

示例

L = [1, 2, 3, 4, 2, 2, 3, 4]
L.remove(3)    #  L = [1, 2, 4, 2, 2, 3, 4]
L.remove(3)    #  L = [1, 2, 4, 2, 2, 4]
L.remove(3)    #  报错了
L.clear()      #  L = []

del 语句删除指定位置的数据元素

语法

del 变量名     # 删除变量，同时解除变量绑定的对象
del 列表[整数表达式]

示例

L = ['张飞', '赵云', '鲁班7号', '孙悟空']
del L[2]    # L = ['张飞', '赵云', '孙悟空']
del L       # 删除L 变量

查看(索引取值就是查看)

print(L[0])  # 取值

列表的常用方法

运算	结果
s.index(x[, i[, j]])	x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）
s.count(x)	x 在 s 中出现的总次数
s.append(x)	将 x 添加到序列的末尾 (等同于 s[len(s):len(s)] = [x])
s.clear()	从 s 中移除所有项 (等同于 del s[:])
s.copy()	创建 s 的浅拷贝 (等同于 s[:])
s.extend(t) 或 s += t	用 t 的内容扩展 s (基本上等同于 s[len(s):len(s)] = t)
s.insert(i, x)	在由 i 给出的索引位置将 x 插入 s (等同于 s[i:i] = [x])
s.pop([i])	提取在 i 位置上的项，并将其从 s 中移除
s.remove(x)	删除 s 中第一个 s[i] 等于 x 的项目。
s.reverse()	就地将列表中的元素逆序。
s.sort( key=None, reverse=False)	对列表内的数据进行排序, reverse=False 升序排序，否则是降序排序

示例:

s = [1, "二", 3]
value = s.pop(1)   # s= [1, 3]; value = '二'
>>> s = [1, 2, 3, 5]
>>> s.reverse()   # 反转
>>> s
[5, 3, 2, 1]
>>> s = [1, 2, 3, 4, 2, 2, 3, 4]
>>> s.index(3)  # 返回第一次出现的位置的索引
2
>>> s.index(3, 4)
6
>>> s.index(100)  # 触发异常，要用try 语句处理
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 100 is not in list
>>> s.count(3)  # 在列表 s 中 找出所有值为3 的元素的个数，并返回
2
>>> s.count(2)
3
>>> L1 = [2, 4, 6, 8, 9, 1]
>>> L1.reverse()
>>> L1
[1, 9, 8, 6, 4, 2]
>>> s.sort()   # 排序，默认是升序排序
>>> s
[1, 2, 2, 2, 3, 3, 4, 4]
>>> s.sort(reverse=True)
>>> s
[4, 4, 3, 3, 2, 2, 2, 1]

列表解析(也叫列表推导式)

作用

用简单的表达式方式来创建列表

语法规则

[ 表达式 for 自定义变量 in 可迭代对象 ]
# 或
[ 表达式 for 自定义变量 in 可迭代对象 if 真值表达式 ]

示例

 生成一个列表， 里面有 100 个数是[1, 4, 9, 16, 25, ...]
# 用 for 语句实现
L = []
for x in range(1, 101):
    L.append(x ** 2)
print(L)

# 用列表推导式
L2 = [ x ** 2 for x in range(1, 101)]
print(L2)

L3 = [ x ** 2 for x in range(1, 101) if x % 2 == 0]  # 取出所有的偶数
# L3 = [4, 16, 36, ...]

python3 中常用于序列的函数

运算	结果
len(s)	s 的长度
min(s)	s 的最小项
max(s)	s 的最大项     # 课间休息:  11:11 回来
sum(s)	求 s内所有数字的和(不允许有其他数据)

>>> L = [1, 5, 8]
>>> len(L)
3
>>> min(L)
1
>>> max(L)
8
>>> sum(L)
14

元组 tuple

元组是不可改变的列表, 同列表list 一样，元组可以存放任意类型的数据，但是，一旦创建将不可修改

创建元组的字面值

用小括号() 括起来，单个元素括起来后加逗号来区分单个元素还是元组
t = ()         # 空元组
t = (100,)     # 含有一个数据元素的元组
t = 100,       # 含有一个数据元素的元组
t = (1, 2, 3)  # 含有三个数据元素的元组
t = 1, 2, 3    # 含有三个数据元素的元组
type(x) 函数用来返回数据x的类型

创建元组的函数 tuple
t = tuple()          # t = ()
t = tuple(range(5))  # t = (0, 1, 2, 3, 4)
tuple 的运算

tuple 是序列的一种，同列表的运算，但是不可以修改元组
>>> t = (1, 2, 3) + (4, 5, 6)
>>> t += (7, 8, 9)
>>> t = t * 2
>>> t *= 2
>>> 5 in t
True
>>> t[0]
1
>>> t[0:2]
(1, 2)
元组的方法
运算	结果
s.index(x[, i[, j]])	x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）
s.count(x)	x 在 s 中出现的总次数
容器都是可迭代对象, 可以用for 语句来遍历容器
for x in [1, 2, 3]:
    print(x)
    
for y in (1, 2, 3):
    print(y)
列表和元组的 +和 += 运算
# 列表(可变)
>>> L1 = [1, 2, 3] + [4, 5, 6]
>>> L2 = L1  # 两个变量同时绑定同一个列表
>>> L2 += [7, 8, 9]
>>> print(L1)   # [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print(L2)   # [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 元组(不可变)
>>> T1 = (1, 2, 3) + (4, 5, 6)
>>> T2 = T1  # 两个变量同时绑定同一个元组
>>> T2 += (7, 8, 9)
>>> print(T1)   # (1，2, 3, 4, 5, 6)
>>> print(T2)   # (1, 2, 3, 4, 5, 6, 7, 8, 9)

字典 dict

什么是字典

        -字典是一种可变的容器，可以存储任意类型的数据

        -字典的数据都是以键(key)-值(value)对的形式进行映射存储.

        -字典的数据是无序的

        -字典的键不能重复，且之能用不可变类型作为字典的键

        -字典中的数据只能用"键"key 进行索引，不能用整数进行索引

创建字典的字面值:

字典的表示方式以 {} 括起来，以英文的冒号 (:) 分隔键值对，各键值对之间用逗号(,)分隔
d = {}    # 创建空字典
d = {'name': "weimingze", "age": 35}
d = {'a': [1, 2, 3]}
d = {'b': {"bb": 222}}
d = {1:'壹', 2:'贰', 5:'伍'}
d = {(1, 2, 3):'壹贰伍'}
以下写法会存在问题
d = {'a': 1, 'b': 2, 'a': 3}  # 字典的键不能重复 d = {'a': 3, 'b': 2}  
d = {[1, 2, 3]: 'a'}          # 不能用可变类型作为字典的键  # 报错
dict 的创建函数 dict
d = dict()   # d = {}
d = dict([("name", "小明"), ("age", 35)])  # {'name': '小明', 'age': 35}
d = dict(a=1, b=2, c=3)    # {'a':1, 'b':2, 'c':3}
d = dict([1, 2, 3, 4])  # 错
注: python 中有四种可变类型

        列表 list

        字典dict

        集合 set

        字节数组 bytearray
persons = [
    {'name': 'weimz', 'age': 35},
    {'name': '小张', 'age': 18},
]
字典的键索引

语法
字典[键key]
用键索引可以查看字典中的数据

示例:
d = {'one': 1, 'two': 2}
print(d['two'])
添加和修改字典的元素

语法
字典[键key] = 表达式
键不存在, 会创建键并绑定键对应的值

键存在, 会改变键对应的值

示例:
d = {}
d['name'] = 'tarena'  # 添加键值对  d = {'name': 'tarena'}
d['age'] = 18         # d = {'name': 'tarena', 'age': 18}
d['age'] = 19         # 改变 'age' 键对应的值 d = {'name': 'tarena', 'age': 19}
删除字典的元素

语法‘
del 字典[键]
示例:
>>> d = dict(a=1, b=2)   # d = {'a': 1, 'b': 2}
>>> del d['a']
>>> d
{'b': 2}
in / not in 运算符

in 可以判断一个键是否存在于字典中,如果存在返回 True, 否则返回 False

not in 与 in 相反

示例
>>> d = dict(a=1, b=2)   # d = {'a': 1, 'b': 2}
>>> 'a' in d
True
>>> 1 in d
False
>>> 'hello' not in d
True
字典是可迭代对象, 字典只能对所有的键进行迭代访问
>>> d = {'name': 'tarena', 'age': 19}
>>> for k in d:
...     print(k)
... 
name
age
>>> for k in d:
...     print("key=", k, 'value=', d[k])
... 
key= name value= tarena
key= age value= 19
字典的常用方法
方法D代表字典	说明D
D.clear()	清空字典
D.copy()	复制
D.get(key[, default])	如果 key 存在于字典中则返回 key 的值，否则返回 default。 如果 default 未给出则默认为 None，因而此方法绝不会引发 KeyError。
D.pop(key)	移除键, 同时返回键对应的值
示例
>>> d = {'name': 'tarena', 'age': 19}
>>> 
>>> d['age']
19
>>> d['address']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'address'
>>> d.get('address', '未填写住址')
'未填写住址'
>>> d.get('age', 0)
19
>>> n = d.pop('name')
>>> d
{ 'age': 19}
>>> n
'tarena'

列表、元组、字典小结

列表和元组是有序的，字典的存储是无序的

列表、字典是可变的,元组是不可变的

字典的键索引速度快，列表的整数索引速度快

列表和元组是顺序存储的，字典是散列存储的
d = {'a':1, 'b':2, .........}
print(d['c'])  # 速度快
L = [7, 5, 1, ........]
print(L[10009])  # 速度快
字典的 in / not in 运算符快于列表的 in / not in 运算符
L = ['孙悟空', '赵云', '吕布', ...]
if '王昭君' in L:    # 速度慢
    pass
D = {'孙悟空':'花果山', '赵云':'长山', '吕布':'石家庄', .....}
if '王昭君' in D:  #  速度快
    pass

集合 set/ 固定集合 frozenset

        集合是可变的容器，固定集合是不可变的集合

        集合相当于只有键没有值的字典

        集合是无序的存储结构

        集合内的数据都是唯一的，不可变

创建集合的方式

        空集合 set()

        非空集合用 {} 括起来，值用逗号分隔开
s = set()            # 用函数空集合
s = {1, 2, 3, 4}     # 创建非空集合的字面值
s = set(range(5))    # 调用 set(可迭代对象) 来创建集合 s = {0, 1, 2, 3, 4}
s = set("ABC")       # s = {'B', 'C', 'A'}
s = set("ABCCCCCCC")  # s = {'B', 'C', 'A'}
s = set(['ABC'])      # s = {'ABC'}
创建固定集合frozensets的方式
fs = frozenset()              # 空固定集合 fs = frozenset()
fs = frozenset([1, 2, 3])     # fs =  frozenset({1, 2, 3})

集合和固定集合的运算

in/ not in 运算符与列表相同
其他运算

&   交集
|   并集
-   补集
^   对称补集
<   子集
>   超集

示例

s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 & s2   # s3 = {2, 3}  # 交集
s4 = s1 | s2   # s4 = {1, 2, 3, 4 }  并集
s5 = s1 - s2   # s5 = {1}   补集
s6 = s1 ^ s2   # s6 = {1, 4}  # 对称补集
s7 = {1, 2} < {1, 2, 3}  # s7 = True
s8 = {1, 2} > {1, 2, 3}  # s8 = False
s9 = {4, 5, 6, 7} > {5, 6}  #  {4, 5, 6, 7} 是 {5, 6} 的超集

集合set的方法

方法	说明
S.add(e)	添加e
S.remove(e)	删除e
S.clear()	清空集合
S.pop()	移除一个并返回，如果集合为空则触发ValueError

容器总结

可变和不可变

可变的容器
list   dict    set        bytearray(字节数组)
不可变得容器
tuple, frozenset, bytes(字节串)
序和乱序

有序
list   tuple    bytes   bytearray
无序
dict    set    frozenset