本文主要是让初学者了解Python，能够看懂官网文档
目录
python 简介
python 的诞生
- 创始人: Guido van Rossum（荷兰人）。
- 时 间 : 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.py2)交互模式
在命令提示符下直接输入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] # Truein /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
106万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
