python基础
python
- 变量和简单类型
- 注释
- 变量
- 数值类型
- 整型
- 浮点型
- 字符串
- 字符串和转义字符
- 字符串拼接（+）
- 数值转换字符串 str() 和 repr()
- 获取用户输入 input()
- 长字符串(''')
- 原始字符串
- 字节串（bytes）
- 字符串的使用
- 转义字符
- 字符串格式化
- 序列相关方法
- 大小写相关方法
- 删除空白
- 字符串查找和替换
- 分割和连接
- 运算符
- 赋值运算符（=）
- 算术运算符
- 位运算符
- 赋值运算符拓展
- 索引运算符
- 比较运算符 与 bool类型
- 逻辑运算符
- 三目运算符 if
- in 与 not in 运算符
- 运算符的结合性和优先级
- 列表、元组和字典
- 列表和元组的通用方法
- 索引
- 子序列 切片（slice）
- 加法
- 乘法
- in运算符
- 长度、最大值和最小值
- 序列封包和序列解包
- 列表的使用
- 创建列表
- 增加列表元素
- 删除列表元素
- 修改列表元素
- 列表的其他常用方法
- 字典的使用
- 创建字典
- 字典的基本用法
- 字典的常用方法
- 使用字典格式化字符串
- 流程控制
- if
- if表达式
- pass语句
- 断言
- 循环结构
- while循环
- for-in 循环
- for-in 循环遍历列表和元组
- for-in 遍历字典
- 循环使用 else
- 嵌套循环
- for 表达式
- 常用工具函数
- zip()
- reversed()
- sorted()
- 控制循环结构
- break结束循环
- continue 忽略本次循环的剩下语句
- return 结束方法
- 函数和lambda表达式
- 函数入门
- 定义函数和调用函数
- 为函数提供文档
- 返回多个值
- 递归函数
- 函数的参数
- 变量的作用域
- 局部函数
- 函数的高级内容
- 使用函数变量
- 函数作为函数形参
- 函数作为返回值
- lambda表达式
变量和简单类型
注释
-
单行注释
python使用井号（#）号表示单行注释的开始，#号后面知道这行结束为止的代码都将被解释器忽略
-
多行注释
使用三个单引号或三个双引号将注释的内容括起来
#这是一行简单的注释 print('Hello World!') ''' 这个是被三个单括号括起来的注释 ''' """ 这个是被三个双括号括起来的注释 """
变量
Python 需要使用标识符给变量命名，其实标识符就是用于给程序中变量、类、 方法命名的符号（简单来说，标识符就是合法的名字）。
Python 语言的标识符必须以字母、下画线(_)开头， 后面可以跟任意数目的字母、数字和下画线(_)。 此处的宇母并不局限于 26 个英文字母，可以包 含中文字符、日文字符等(python3 支持UTF-8)。
Python 语言是区分大小写的，因此 abc 和 Abe 是两个不同的标识符。
Python 使用等号（＝）作为赋值运算符
Python 是弱类型语言，弱类型语言有两个典型特征。
-
变量无须声明即可直接赋值： 对一个不存在的变量赋值就相当于定义了一个新变量。
-
变量的数据类型可以动态改变：同一个变量可以一会儿被赋值为整数值， 一会儿被赋值为 字符串。
在使用标识符时，需要注意如下规则。
- 标识符可以由字母、数字、下画线（_）组成，其中数字不能打头。
- 标识符不能是 Python 关键字，但可以包含关键字。
- 标识符不能包含空格。
Python 还包含一系列关键字和内置函数， 一般也不建议使用它们作为变量名 。
-
如果开发者尝试使用关键字作为变量名 ， Python 解释器会报错。
-
如果开发者使用内置函数的名字作为变量名， Python 解释器倒不会报错，只是该内置函数 就被这个变量覆盖了，该内置函数就不能使用了 。
Python 关键字
| False | None | True | and | as |
| assert | break | class | continue | def |
| del | elif | else | except | finally |
| for | from | global | if | import |
| in | is | lambda | monlocal | not |
| or | pass | raise | return | try |
| while | with | yield |
python 内置函数
| abs() | all() | any() | basestring() | bin() |
| bool() | bytearray() | callable() | chr() | classmethod() |
| cmp() | compile() | complex() | delattr() | dict() |
| dir() | divmod() | enumerate() | eval() | execfile() |
| file() | filter() | float() | format() | frozenset() |
| getattr() | globals() | hasattr() | hash() | help() |
| hex() | id() | input() | int() | isinstance() |
| issubclass() | iter() | len() | list() | locals() |
| long() | map() | max() | memoryview() | min() |
| next() | object() | oct() | open() | ord() |
| pow() | print() | property() | range() | raw_input() |
| reduce() | reload() | repr() | reversed() | zip() |
| round() | set() | setattr() | slive() | sorted() |
| staticmethod() | str() | sum() | super() | tuple() |
| type() | unichr() | unicode() | vars() | xrange() |
| Zip() | __import__() | apply() | buffer() | coerce() |
| intem |
数值类型
整型
Python 3 的整型支持各种整数值，不管是小的整数值，还是大的整数值
＃定义变量 a，赋值为 56
a = 56
print(a)
＃为 a 赋值一个大整数
a = 9999999999999999999999
print(a)
# type （）函数用于返回变量的类型 print (type (a))
Python 的整型支持 None 值（空值）
a = None
print(a)
Python 的整型数值有 4 种表示形式。
- 十进制形式： 最普通的整数就是十进制形式的整数。
- 二进制形式：以 0b 或 0B 开头的整数就是二进制形式的整数。
- 八进制形式： 以0o 或 0O开头的整数就是八进制形式的整数（第二个字母是大写或小写的 0）。
- 十六进制形式：以 0x 或0X 开头的整数就是十六进制形式的整数，其中 10～15 分别以 a-f （此处的a～f不区分大小写）来表示。
下面代码片段使用了其他进制形式的数。
＃以 0x 或 0X开头的整型数值是十六进制形式的整数
hex_valuel = 0x13
hex_value2 = 0XaF
print("hexValuel 的值为："， hex_valuel)
print("hexValue2 的值为："， hex_value2)
＃以 0b 或 0B 开头的整型数值是二进制形式的整数
bin_val = 0b111
print('bin_val 的值为：'， bin_ val)
bin_val = 0B101
print('bin_val 的值为：'， bin_val)
＃ 以 0o 或 0O 开头的整型数值是八进制形式的整数
oct_val = 0o54
print('oct_val 的值为：'， oct_val)
oct_val= 0017
print('ct_val 的值为：'， oct_val)
浮点型
浮点型数值用于保存带小数点的数值， Python 的浮点数有两种表示形式。
- 十进制形式：这种形式就是平常简单的浮点数，例如 5.12、 512.0、 0.512。浮点数必须包含 一个小数点，否则会被当成整数类型处理。
- 科学计数形式： 例如 5.12e2 、 5.12E2 。
字符串
Python 要求字符串必须使用引号括起来,单引号和双引号都行.
字符串和转义字符
- 使用不通的引号将字符串括起来
str1 = "I'm a coder" str2 = '"Spring is here, let us jam!", said woodchuck .' - 使用转义字符（\）
str3 = '"we are scared, Let\'s hide in hte shade",says the bird'
字符串拼接（+）
s1 = "Hello," 'Charlie'
print(s1)
s2 = "Python "
s3 = "is Funny"
# 使用+拼接字符串
s4 = s2 + s3
print(s4)
数值转换字符串 str() 和 repr()
s1 = "这本书的价格是："
p = 99.8
# 字符串直接拼接数值，程序报错
#print(s1 + p)
# 使用str()将数值转换成字符串
print(s1 + str(p))
# 使用repr()将数值转换成字符串
print(s1 + repr(p))
st = "I will play my fife"
print(st)
print(repr(st))
获取用户输入 input()
由于 input（） 函数总会将用户输入的内容放入字符串中，因此用户可 以输入任何内容， input（）函 数总是返回一个字符串。
msg = input("请输入你的值：")
print(type(msg))
print(msg)
长字符串(’’’)
长字符串可以让字符串中包含任何内容，既可包含单引号，也可包含双引号
Python 还允许使用转义字符（＼） 换行符进行转义，转义之后的换行符不会“中断”字符串
s = '''"Let's go fishing", said Mary.
"OK, Let's go", said her brother.
they walked to a lake'''
print(s)
s2 ='The quick brown fox \
jumps over the lazy dog'
print(s2)
num = 20 + 3 / 4 + \
2 * 3
print(num)
原始字符串
原始字符串以“ ”开头 原始宇符串不会把反斜线当成特殊字符。
s1 = r'G:\publish\codes\02\2.4'
print(s1)
# 原始字符串包含的引号，同样需要转义
s2 = r'"Let\'s go", said Charlie'
print(s2)
#由于原始字符串中 的反斜线会对 引号进行转义，因此原始字符串的结尾处不能是反斜线一宇衍串结尾处的引 号就被转义了 ，这样就导致字符串不能正确结束。
s3 = r'Good Morning' '\\'
print(s3)
字节串（bytes）
bytes 对象只负责以宇节（二进制格式）序列来记录数据，至于这些数据到底表示 么内容，完全由程序决定。 如果采用合适的字符集 字符串 可以转换成字节串；反过来，宇节串也可以恢复成对应的字符串
bytes 保存的就是原始的字节（二进制格式）数据，因此 bytes 对象可用于在网络上传输数据 ，也可用于存储各种二进制格式的文件， 比如 图片、音乐等文件
字符串转换成 bytes 有如下 种方式：
- 如果字符串内容都是 ASCII 字符，则可以通过直接在字符串之前添加b来构建字节串值
- 调用 bytes()函数（其实是 bytes 构造方法）将字符串按指定 符集转换成字节串，如果不指定字符集，默认使用 UTF-8 字符集。
- 调用字符串本身 encode（） 方法将字符串按指定字符集转换成字节串，如果不指定字符集， 默认使用 UTF-8字符集。
- bytes转换字符串 ：decode()
例如，如下程序示范了如何创建字节串。
# 创建一个空的bytes
b1 = bytes()
# 创建一个空的bytes值
b2 = b''
# 通过b前缀指定hello是bytes类型的值
b3 = b'hello'
print(b3)
print(b3[0])
print(b3[2:4])
# 调用bytes方法将字符串转成bytes对象
b4 = bytes('我爱Python编程',encoding='utf-8')
print(b4)
# 利用字符串的encode()方法编码成bytes，默认使用utf-8字符集
b5 = "学习Python很有趣".encode('utf-8')
print(b5)
# 将bytes对象解码成字符串，默认使用utf-8进行解码。
st = b5.decode('utf-8')
print(st) # 学习Python很有趣
字符串的使用
转义字符
python支持的转义字符
| 转义字符 | 说明 |
|---|---|
| \b | 退格符 |
| \n | 换行符 |
| \r | 回车符 |
| \t | 制表符 |
| " | 双引号 |
| ’ | 单引号 |
| \ | 反斜线 |
s = 'Hello\nCharlie\nGood\nMorning'
print(s)
输出结果
Hello
Charlie
Good
Morning
s2 = '商品名\t\t单价\t\t数量\t\t总价'
s3 = 'python\t108\t\t2\t\t316'
print(s2)
print(s3)
输出结果
商品名 单价 数量 总价
python 108 2 216
字符串格式化
python提供了“%”对各种类型的数据进行格式化输出
price = 108
print("the book's price is %x" % price)
这行代码中的print函数包含三个部分，第一部分是格式字符串（相当于字符串的模版），其中包含一个“%s”占位符，它会被第三部分的变量或表达式的值代替。
格式化字符串中包含多个占位符，第三部分也应该提供多个变量，并且使用圆括号将这些变量括起来。
user = "Charli"
age = 8
# 格式化字符串有两个占位符，第三部分提供2个变量
print("%s is a %s years old boy" % (user , age))
转换说明符
| 转换说明符 | 说明 |
|---|---|
| d,i | 转换为带符号的十进制形式的整数 |
| o | 转换为带符号的八进制形式的整数 |
| x | 转换为带符号的十六进制形式的整数 |
| X | 转换为带符号的十六进制形式的整数 |
| e | 转换为科学计数法表示的浮点数（e小写） |
| E | 转换为科学计数法表示的浮点数（E大写） |
| f,F | 转换为十进制形式的浮点数 |
| g | 智能选择使用f或e格式 |
| G | 智能选择使用F或E格式 |
| C | 转换为单字符（只接受整数或单字符字符串） |
| r | 使用repr()将变量或表达式转换为字符串 |
| s | 使用str()将变量或表达式转换为字符串 |
num = -28
print("num is: %6i" % num)
print("num is: %6d" % num)
print("num is: %6o" % num)
print("num is: %6x" % num)
print("num is: %6X" % num)
print("num is: %6s" % num)
num2 = 30
# 最小宽度为0，左边补0
print("num2 is: %06d" % num2)
# 最小宽度为6，左边补0，总带上符号
print("num2 is: %+06d" % num2)
# 最小宽度为6，右对齐
print("num2 is: %-6d" % num2)
my_value = 3.001415926535
# 最小宽度为8，小数点后保留3位
print("my_value is: %8.3f" % my_value)
# 最小宽度为8，小数点后保留3位，左边补0
print("my_value is: %08.3f" % my_value)
# 最小宽度为8，小数点后保留3位，左边补0，始终带符号
print("my_value is: %+08.3f" % my_value)
the_name = "Charlie"
# 只保留3个字符
print("the name is: %.3s" % the_name) # 输出Cha
# 只保留2个字符，最小宽度10
print("the name is: %10.2s" % the_name)
序列相关方法
字符串本质上是由多个字符组成，因此允许通过索引来操作字符
python字符串直接在方括号（[]）中使用索引即可获取对应的字符，第一个字符索引为0，第二个为1，倒数第一个为-1
获取一段用（：）
s = 'crazyit.org is very good'
# 获取s中索引2处的字符
print(s[2]) # 输出a
# 获取s中从右边开始，索引4处的字符
print(s[-4]) # 输出g
# 获取s中从索引3处到索引5处（不包含）的子串
print(s[3: 5]) # 输出zy
# 获取s中从索引3处到倒数第5个字符的子串
print(s[3: -5]) # 输出zyit.org is very
# 获取s中从倒数第6个字符到倒数第3个字符的子串
print(s[-6: -3]) # 输出y g
# 获取s中从索引5处到结束的子串
print(s[5: ]) # 输出it.org is very good
# 获取s中从倒数第6个字符到结束的子串
print(s[-6: ]) # 输出y good
# 获取s中从开始到索引5处的子串
print(s[: 5]) # 输出crazy
# 获取s中从开始到倒数第6个字符的子串
print(s[: -6]) #输出crazyit.org is ver
# 判断s是否包含'very'子串
print('very' in s) # True
print('fkit' in s) # False
# 输出s的长度
print(len(s)) # 24
# 输出'test'的长度
print(len('test')) # 4
# 输出s字符串中最大的字符
print(max(s)) # z
# 输出s字符串中最小的字符
print(min(s)) # 空格
大小写相关方法
在str类中与大小写相关的常用方法如下。
- title()：将每个单词 首字母改为大写
- lower()：将整个字符串改为小写
- upper()： 将整个字符串改为大写。
a = 'our domain is crazyit.org'
# 每个单词首字母大写
print(a.title())
# 每个单词首字母小写
print(a.lower())
# 每个单词首字母大写
print(a.upper())
删除空白
str 还提供了如下常用的方法来删除空白。
- strip():删除字符串前后 空白。
- strip():删除字符串前面（左边）的空白。
- rstrip(): 删除字符串后面（右边）的空白。
s = ' this is a puppy '
# 删除左边的空白
print(s.lstrip())
# 删除右边的空白
print(s.rstrip())
# 删除两边的空白
print(s.strip())
# 再次输出s，将会看到s并没有改变
print(s)
s2 = 'i think it is a scarecrow'
# 删除左边的i、t、o、w字符
print(s2.lstrip('itow'))
# 删除右边的i、t、o、w字符
print(s2.rstrip('itow'))
# 删除两边的i、t、o、w字符
print(s2.strip('itow'))
字符串查找和替换
str 还提供了如下常用的执行查找 、替换等操作的方法
- startswith()：判断字符串是否 以指定子串开头。
- endswith()：判断字符串是否以指定子串结尾
- find()： 查找指定子串在字符串中出现的位置，如果没有找到指定子串，则返回-1
- index()： 查找指定子串在字符串中出现的位置，如果没有找到指定子串，则引发ValueError错误。
- replace()： 使用指定子串替换字符串中的目标子串
- translate()： 使用指定的翻译映射表对字符串执行替换。
s = 'crazyit.org is a good site'
# 判断s是否以crazyit开头
print(s.startswith('crazyit'))
# 判断s是否以site结尾
print(s.endswith('site'))
# 查找s中'org'的出现位置
print(s.find('org')) # 8
# 查找s中'org'的出现位置
print(s.index('org')) # 8
# 从索引为9处开始查找'org'的出现位置
#print(s.find('org', 9)) # -1
# 从索引为9处开始查找'org'的出现位置
print(s.index('org', 9)) # 引发错误
# 将字符串中所有it替换成xxxx
print(s.replace('it', 'xxxx'))
# 将字符串中1个it替换成xxxx
print(s.replace('it', 'xxxx', 1))
# 定义替换表：97（a）->945（α）,98（b）->945（β）,116（t）->964（τ）,
table = {97: 945, 98: 946, 116: 964}
print(s.translate(table)) # crαzyit.org is α good site
Python 为str类提供了一个 maketrans()方法，通过该方法可以非常方便地创建翻
译映射表
>>> table = str.maketrans('abt', '123')
>>> table
{97: 49, 98: 50, 116: 51}
>>>
分割和连接
Python 还为 str 提供了分割和连接方法
- split()： 将字符串按指定分割符分割成多个短语
- join()：将 多个短 吾连接成字符串
s = 'crazyit.org is a good site'
# 使用空白对字符串进行分割
print(s.split()) # 输出 ['crazyit.org', 'is', 'a', 'good', 'site']
# 使用空白对字符串进行分割,最多只分割前2个单词
print(s.split(None, 2)) # 输出 ['crazyit.org', 'is', 'a good site']
# 使用点进行分割
print(s.split('.')) # 输出 ['crazyit', 'org is a good site']
mylist = s.split()
# 使用'/'为分割符，将mylist连接成字符串
print('/'.join(mylist)) # 输出 crazyit.org/is/a/good/site
# 使用','为分割符，将mylist连接成字符串
print(','.join(mylist)) # 输出 crazyit.org,is,a,good,site
运算符
赋值运算符（=）
# 为变量st赋值为Python
st = "Python"
# 为变量pi赋值为3.14
pi = 3.14
# 为变量visited赋值为True
visited = True
print(st)
print(pi)
print(visited)
# 将变量st的值赋给st2
st2 = st
print(st2)
a = b = c = 20
print(a)
print(b)
print(c)
d1 = 12.34
# 将表达式的值赋给d2
d2 = d1 + 5
# 输出d2的值
print("d2的值为：%g" % d2 ) # 17.34
算术运算符
#++++++++++
a = 5.2
b = 3.1
the_sum = a + b
# sum的值为8.3
print("the_sum的值为：", the_sum)
#连接字符串
s1 = 'Hello, '
s2 = 'Charlie'
# 使用+连接两个字符串
print(s1 + s2)
#— - - - - - -
c = 5.2
d = 3.1
sub = c - d
# sub的值为2.1
print("sub的值为：", sub)
#***************
e = 5.2
f = 3.1
multiply = e * f
# multiply的值为16.12
print("multiply的值为：", multiply)
#连接字符串
s3 = 'crazyit '
# 使用*将5个字符串连接起来
#输出结果为：crazyit crazyit crazyit crazyit crazyit
print(s3 * 5)
#/ / / / / / / / /
#/ 普通除法，除不尽产生小数
#// 整除，小数舍弃
print("19/4的结果是:", 19/4)
print("19//4的结果是:", 19//4)
aa = 5.2
bb = 3.1
# aa / bb的值将是1.67741935483871
print("aa/bb的值是:", aa / bb)
# aa // bb值将是1.0
print("aa//bb的值是:", aa // bb)
#% % % % % % % % % %
#求余
print("5%3的值为：", 5 % 3) # 输出2
print("5.2%3.1的值为：", 5.2 % 3.1) # 输出2.1
print("-5.2%-3.1的值为：", -5.2 % -3.1) # 输出-2.1
print("5.2%-2.9的值为：", 5.2 % -2.9) # 输出-0.6
print("5.2%-1.5的值为：", 5.2 % -1.5) # 输出-0.8
print("-5.2%1.5的值为：", -5.2 % 1.5) # 输出0.8
#print("5对0.0求余的结果是:", 5 % 0.0) # 导致错误
#** ** ** ** ** ** **
#乘方运算符 **
print('5的2次方：', 5 ** 2) # 25
print('4的3次方：', 4 ** 3) # 64
print('4的开平方：', 4 ** 0.5) # 2.0
print('27的开3次方：', 27 ** (1 / 3)) # 3.0
位运算符
位运算符通常在图形、 图像处理和创建设备驱动等底层开发中使用 。 使用位运算符可以直接操作数值的原始 bit 位， 尤其是在使用自定义的协议进行通信时，使用位运算符对原始数据进行编码和解码也非常有效。
| 位运算符 | 说明 |
|---|---|
| & | 按位与 |
| | | 按位或 |
| ^ | 按位异或 |
| ~ | 按位取反 |
| << | 左位移运算符 |
| >> | 右位移运算符 |
位运算符的运算法则
| 第一操作数 | 第二操作数 | 按位与 | 按位或 | 按位异或 |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 0 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
所有数值在计算机底层都是以二进制形式存在的，原码是直接将一个数值换算成二进制数。
有符号整数的最高位是符号位，符号位为0代表正数， 符号位为1代表负数。
无符号整数则没有符号位，因此无符号整数只能表示 0和正数。
为了方便计算，计算机底层以补码的形式保存所有的整数。
补码的计算规则是：
- 正数的补码和原码完全相同
- 负数的补码是其反码加1
反码是对原码按位取反，只是最高位（符号位）保持不变。
在进行位移运算时，不难友现，左移 n 位就相当于来以 2 的 11 次方，右移 n 位则相当于除以 2 的 n 次方（如果不能整除，实际返回的结果是小于除得结果数值的最大整数的）。不仅如此，进行位移运算只是得到 了 一个新的运算结果，而原来的操作数本身是不会改变的 。
# 将输出1
print(5 & 9)
# 将输出13
print(5 | 9)
a = -5
# 将输出4
print( ~a)
# 将输出12
print(5 ^ 9)
# 输出20
print(5 << 2)
# 输出-20
print(-5 << 2)
b = -5
# 输出-2
print(b >> 2)
赋值运算符拓展
+＝：对于 x+= y， 即对应于 x = x+y 在使用索引范围时，还可指定步长 bool类型： 比较运算符： 逻辑运算符用于操作 bool类型的变量、常量或表达式，逻辑运算的返回值也是 bool值。 逻辑运算符 三目运算符的规则是： 先对逻辑表达式 expression 求值，如果逻辑表达式返回 True，则执行并返回 True_statements 的值；如果逻辑表达式返回 False， 则执行并返回 False_statements 的值 判断某个成员是否位于序列中 Python 语言中的大部分运算符也是从左向右结合的， 只有单目运算符、 赋值运算符和三目运算符例外，它们是从右向左结合的，也就是说，它们是从右向左运算的。 乘法和加法是两个可结合的运算符，也就是说，这两个运算符左右两边的操作数可以互换位置而不会影响结果。 运算符的优先级 切片语法 [start : end : step] 不包含 end 元素 python允许两种赋值方式： 程序把多个值赋给一个变量时，python会自动将多个值封装成元组，这被称为序列封包 程序允许将序列（元组或列表等）直接赋值给多个变量，序列的各个元素会被依次赋值给每个变量（要求序列的元素个数和变量的个数相等） 这称为解包 列表的创建 元组的创建 if语句的形式： python的pass语句是空语句 断言语句和 if 分支有点类似，它用于对一个bool 表达式进行断言，如果该 bool 表达式为True,该程序可以继续向下执行，否则程序会引发 AssertionError 错误 上面 4个部分只是一般分类，并不是每个循环中都非常清晰地分出这4个部分。 while 语法： for-in 循环专门用于遍历范围、列表、元素和字典等可迭代对象包含的元素。 字典包含三个方法： for表达式用于利用其它区间、元组、列表等可迭代对象创建新的列表。 [表达式 for 循环计数器 in 可迭代对象] for表达式与for循环的区别： 把两个或多个列表‘压缩‘成一个zip对象（可迭代）就可以使用一个循环并行遍历多个列表。 若列表的长度不相等 ，以最短的为准 接收各种序列参数，返回一个‘反序排列’的迭代器 对参数本身不会产生任何影响 接收序列参数，返回一个新的、排序好的列表 break 结束循环 跳出循环体 结束函数 或方法 定义函数的语法： 编写说明文档：把一段字符串放在函数的声明之后，函数体之前，这段字符串将被作为函数的部分，这个文档就是函数的说明文档。 通过 help() 或 __doc__查看函数的说明文档 函数返回多个值，可以将多个值包装成列表之后返回，也可以直接返回。如果是直接返回多个值，python会自动将多个返回值封装成元组。 递归函数：在一个函数体内调用它自身。 递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无需循环控制。 递归函数不断调用自身时，必须在某个时刻函数的返回值是固定的 ，不再调用自身，否则会变成无穷递归。 位置参数：按照形参位置传入的参数值 默认参数：有默认值的参数 可变参数：参数前加*号，该参数可接收多个参数值，多个值被当成元组输入，参数收集 *args 关键字参数：根据参数名传入参数值，一个或多个，多个用**收集，当做字典 ，**kw 命名关键字参数：只接收后面关键字的参数。（,name,age）只接收关键字是name，age的参数 获取指定范围内的变量： 全局函数：在全局范围内定义函数 局部函数只能在封闭函数内有效，其封闭函数也可以返回局部函数，以便程序在其他作用域中使用局部函数 nonlocal 声明访问赋值语句只是访问该函数所在函数内的局部变量 函数也是一种值，所有函数都是function对象，可以把函数本身赋值给变量，程序也可以通过该变量来调用函数。 lambda表达式语法格式：
-＝：对于 x -＝ y，即对应于 x= x-y
*＝： 对于 x *= y，即对应于 x=x* y
/＝： 对于 x /= y，即对应于 x = x /y
//＝： 对于 x II= y，即对应于 x = x //y
%＝： 对于 x %=y，即对应于 x=x%y
**＝： 对于 x **= y，即对应于 x=x **y
＆＝： 对于 x &=y，即对应于 x = x & y
|＝： 对于 x|= y，即对应于 x = x I y
^＝：对于 x ^= y， 即对应于 x= x ^ y
<<＝：对于 x<<=y，即对应于 x = x << y
>>＝：对于 x >>= y，即对应于 x=x<索引运算符
a = 'abcdefghijklmn'
# 获取索引2到索引8的子串，步长为3
print(a[2:8:3]) # 输出cf
# 获取索引2到索引8的子串，步长为2
print(a[2:8:2]) # 输出ceg
比较运算符 与 bool类型
- True ：表示真
- False ：表示假
符号
说明
>
大于，正确傅安辉True，错误返回False
<
小于，正确傅安辉True，错误返回False
>=
大于或等于，正确傅安辉True，错误返回False
<=
小于或等于，正确傅安辉True，错误返回False
==
等于，正确傅安辉True，错误返回False
!=
不等于，正确傅安辉True，错误返回False
is
判断两个变量引用的对象是否相同，相同True
is not
判断两个变量引用的对象是否不同，不同True
# 输出True
print("5是否大于 4：", 5 > 4)
# 输出False
print("3的4次方是否大于等于90.0：", 3 ** 4 >= 90)
# 输出True
print("20是否大于等于20.0：", 20 >= 20.0)
# 输出True
print("5和5.0是否相等：", 5 == 5.0)
# 输出False
print("True和False是否相等：", True == False)
# 输出True
# True可以当成整数1使用
print("1和True是否相等：", 1 == True)
# 输出True
# False可以当做整数0使用
print("0和False是否相等：", 0 == False)
print(True + False) # 输出1
print(False - True) # 输出-1
import time
# 获取当前时间
# == 两个变量数值是否相等
# is 两个变量是否为同一个对象
a = time.gmtime()
b = time.gmtime()
print(a == b) # a和b两个时间相等，输出True
print(a is b) # a和b不是同一个对象，输出False
print(id(a))
print(id(b))
逻辑运算符
运算符
说明
and
与，两个操作数必须都为True，返回True
or
或，两个操作数中一个为True,返回True
not
非，只有一个操作数，True返回False，False返回True
# 直接对False求非运算，将返回True
print(not False)
# 5>3返回True，20.0大于10，因此结果返回True
print(5 > 3 and 20.0 > 10)
# 4>=5返回False，"c">"a"返回True。求或后返回True
print(4 >= 5 or "c" > "a")
三目运算符 if
True_statements if expression else False_statements
a = 5
b = 3
st = "a大于b" if a > b else "a不大于b"
# 输出"a大于b"
print(st)
# 输出"a大于b"
print("a大于b") if a > b else print("a不大于b")
# 第一个返回值部分使用两条语句，逗号隔开
# 每条语句都会执行， 程序返回多条语句的返回值组成的元组
st = print("crazyit"), 'a大于b' if a > b else "a不大于b"
print(st)
# 第一个返回值部分使用两条语句，分号隔开
# 每条语句都会执行，程序只返回第一条语句的返回值。
st = print("crazyit"); x = 20 if a > b else "a不大于b"
print(st)
print(x)
# 三目运算符的嵌套
c = 5
d = 5
# 下面将输出c等于d
print("c大于d") if c > d else (print("c小于d") if c < d else print("c等于d"))
in 与 not in 运算符
s = 'crazyit.org'
print('it' in s) # True
print('it' not in s) # False
print('fkit' in s) # False
print('fkit' not in s) # True
运算符的结合性和优先级
运算符说明
python运算符
优先级
索引运算符
x[index]或 x[index: index2[:index3]]
18，19
属性访问
x.attribute
17
乘方
**
16
按位取反
~
15
符号运算符
+或-
14
乘除
*、/、//、%
13
加减
+、 -
12
位移
>>、 <<
11
按位与
&
10
按位异或
^
9
按位或
|
8
比较运算符
==、!=、>、>=、<、<=
7
is运算符
is、is not
6
in运算符
in 、not in
5
逻辑非
not
4
逻辑与
and
3
逻辑或
or
2
列表、元组和字典
列表
元组
字符串
字典
可变性
可变
不可变
不可变
可变
有序性
有序
有序
有序
无序
索引方式
[0]开始
[0]开始
[0]开始
key
表示形式
[,]
(,)
‘’
{key:value,}
列表和元组的通用方法
索引
a_tuple = ('crazyit', 20, 5.6, 'fkit', -17)
print(a_tuple)
# 访问第1个元素
print(a_tuple[0]) # crazyit
# 访问第2个元素
print(a_tuple[1]) # 20
# 访问倒数第1个元素
print(a_tuple[-1]) # -17
# 访问倒数第2个元素
print(a_tuple[-2]) # -fkit
子序列 切片（slice）
a_tuple = ('crazyit', 20, 5.6, 'fkit', -17)
# 访问从第2个到倒数第4个（不包含）所有元素
print(a_tuple[1: 3]) # (20, 5.6)
# 访问从倒数第3个到倒数第1个（不包含）所有元素
print(a_tuple[-3: -1]) # (5.6, 'fkit')
# 访问从第2个到倒数第2个（不包含）所有元素
print(a_tuple[1: -2]) # (20, 5.6)
# 访问从倒数第3个到第5个（不包含）所有元素
print(a_tuple[-3: 4]) # (5.6, 'fkit')
b_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9)
# 访问从第3个到第9个（不包含）、间隔为2的所有元素
print(b_tuple[2: 8: 2]) # (3, 5, 7)
# 访问从第3个到第9个（不包含）、间隔为3的所有元素
print(b_tuple[2: 8: 3]) # (3, 6)
# 访问从第3个到倒数第2个（不包含）、间隔为3的所有元素
print(b_tuple[2: -2: 2]) # (3, 5, 7)
加法
a_tuple = ('crazyit' , 20, -1.2)
b_tuple = (127, 'crazyit', 'fkit', 3.33)
# 计算元组相加
sum_tuple = a_tuple + b_tuple
print(sum_tuple) # ('crazyit', 20, -1.2, 127, 'crazyit', 'fkit', 3.33)
print(a_tuple) # a_tuple并没有改变
print(b_tuple) # b_tuple并没有改变
# 两个元组相加
print(a_tuple + (-20 , -30)) # ('crazyit', 20, -1.2, -20, -30)
# 下面代码报错：元组和列表不能直接相加
#print(a_tuple + [-20 , -30])
a_list = [20, 30, 50, 100]
b_list = ['a', 'b', 'c']
# 计算列表相加
sum_list = a_list + b_list
print(sum_list) # [20, 30, 50, 100, 'a', 'b', 'c']
print(a_list + ['fkit']) # [20, 30, 50, 100, 'fkit']
乘法
a_tuple = ('crazyit' , 20)
# 执行乘法
mul_tuple = a_tuple * 3
print(mul_tuple) # ('crazyit', 20, 'crazyit', 20, 'crazyit', 20)
a_list = [30, 'Python', 2]
mul_list = a_list * 3
print(mul_list) # [30, 'Python', 2, 30, 'Python', 2, 30, 'Python', 2]
# 同时对元组使用加法、乘法
order_endings = ('st', 'nd', 'rd')\
+ ('th',) * 17 + ('st', 'nd', 'rd')\
+ ('th',) * 7 + ('st',)
# 将会看到st、nd、rd、17个th、st、nd、rd、7个th、st
print(order_endings)
day = input("输入日期(1-31)：")
# 将字符串转成整数
day_int = int(day)
print(day + order_endings[day_int - 1])
in运算符
a_tuple = ('crazyit' , 20, -1.2)
print(20 in a_tuple) # True
print(1.2 in a_tuple) # False
print('fkit' not in a_tuple) # True
长度、最大值和最小值
# 元素必须为相同的类型
# 元素都是数值的元组
a_tuple = (20, 10, -2, 15.2, 102, 50)
# 计算最大值
print(max(a_tuple)) # 102
# 计算最小值
print(min(a_tuple)) # -2
# 计算长度
print(len(a_tuple)) # 6
# 元素都是字符串的列表
b_list = ['crazyit', 'fkit', 'Python', 'Kotlin']
# 计算最大值（依次比较每个字符的ASCII码值，先比较第一个字符，若相同，继续比较第二个字符，以此类推）
print(max(b_list)) # fkit（26个小写字母的ASCII码为97~122）
# 计算最小值
print(min(b_list)) # Kotlin （26个大写字母的ASCII码为65~90）
# 计算长度
print(len(b_list)) # 4
序列封包和序列解包
# 序列封包：将10、20、30封装成元组后赋值给vals
vals = 10, 20, 30
print(vals) # (10, 20, 30)
print(type(vals)) # 列表的使用
创建列表
# 1.使用方括号定义列表
my_list = ['crazyit', 20, 'Python']
print(my_list)
# 2.python 提供list()函数创建列表
a_tuple = ('crazyit', 20, -1.2)
# 将元组转换成列表
a_list = list(a_tuple)
print(a_list)
# 使用range()函数创建区间（range）对象
a_range = range(1, 5)
print(a_range) # range(1, 5)
# 将区间转换成列表
b_list = list(a_range)
print(b_list) #[1, 2, 3, 4]
# 创建区间时还指定步长
c_list = list(range(4, 20, 3))
print(c_list) # [4, 7, 10, 13, 16, 19]
# 1.使用方括号定义列表
my_tuple = ('crazyit', 20, 'Python')
print(my_tuple)
# 2.python 提供了tuple()函数创建元组
a_list = ['crazyit', 20, -1.2]
# 将列表转换成元组
a_tuple = tuple(a_list)
print(a_tuple)
# 使用range()函数创建区间（range）对象
a_range = range(1, 5)
print(a_range) # range(1, 5)
# 将区间转换成元组
b_tuple = tuple(a_range)
print(b_tuple) #[1, 2, 3, 4]
# 创建区间时还指定步长
c_tuple = tuple(range(4, 20, 3))
print(c_tuple) # [4, 7, 10, 13, 16, 19]
增加列表元素
# append() 追加元素
a_list = ['crazyit', 20, -2]
# 追加元素
a_list.append('fkit')
print(a_list) # ['crazyit', 20, -2, 'fkit']
a_tuple = (3.4, 5.6)
# 追加元组，元组被当成一个元素
a_list.append(a_tuple)
print(a_list) # ['crazyit', 20, -2, 'fkit', (3.4, 5.6)]
# 追加列表，列表被当成一个元素
a_list.append(['a', 'b'])
print(a_list) # ['crazyit', 20, -2, 'fkit', (3.4, 5.6), ['a', 'b']]
# extend()追加元素
b_list = ['a', 30]
# 追加元组中的所有元素
b_list.extend((-2, 3.1))
print(b_list) # ['a', 30, -2, 3.1]
# 追加列表中的所有元素
b_list.extend(['C', 'R', 'A'])
print(b_list) # ['a', 30, -2, 3.1, 'C', 'R', 'A']
# 追加区间中的所有元素
b_list.extend(range(97, 100))
print(b_list) # ['a', 30, -2, 3.1, 'C', 'R', 'A', 97, 98, 99]
# insert() 插入元素
c_list = list(range(1, 6))
print(c_list) # [1, 2, 3, 4, 5]
# 在索引3处插入字符串
c_list.insert(3, 'CRAZY' )
print(c_list) # [1, 2, 3, 'CRAZY', 4, 5]
# 在索引3处插入元组，元组被当成一个元素
c_list.insert(3, tuple('crazy'))
print(c_list) # [1, 2, 3, ('c', 'r', 'a', 'z', 'y'), 'CRAZY', 4, 5]
删除列表元素
# del 删除列表元素
a_list = ['crazyit', 20, -2.4, (3, 4), 'fkit']
# 删除第3个元素
del a_list[2]
print(a_list) # ['crazyit', 20, (3, 4), 'fkit']
# 删除第2个到第4个（不包含）元素
del a_list[1: 3]
print(a_list) # ['crazyit', 'fkit']
b_list = list(range(1, 10))
# 删除第3个到倒数第2个（不包含）元素，间隔为2
del b_list[2: -2: 2]
print(b_list) # [1, 2, 4, 6, 8, 9]
# 删除第3个到第5个（不包含）元素
del b_list[2: 4]
print(b_list) # [1, 2, 8, 9]
# del 删除变量
name = 'crazyit'
print(name) # crazyit
# 删除name变量
del name
#print(name) # NameError
# remove() 删除列表元素，
c_list = [20, 'crazyit', 30, -4, 'crazyit', 3.4]
# 删除第一次找到的30
c_list.remove(30)
print(c_list) # [20, 'crazyit', -4, 'crazyit', 3.4]
# 删除第一次找到的'crazyit'
c_list.remove('crazyit')
print(c_list) # [20, -4, 'crazyit', 3.4]
# clear() 清空列表元素
c_list.clear()
print(c_list) # []
修改列表元素
a_list = [2, 4, -3.4, 'crazyit', 23]
# 对第3个元素赋值
a_list[2] = 'fkit'
print(a_list) # [2, 4, 'fkit', 'crazyit', 23]
# 对倒数第2个元素赋值
a_list[-2] = 9527
print(a_list) # [2, 4, 'fkit', 9527, 23]
b_list = list(range(1, 5))
print(b_list)
# 将第2个到第4个（不包含）元素赋值为新列表的元素
b_list[1: 3] = ['a', 'b']
print(b_list) # [1, 'a', 'b', 4]
# 将第3个到第3个（不包含）元素赋值为新列表的元素，就是插入
b_list[2: 2] = ['x', 'y']
print(b_list) # [1, 'a', 'x', 'y', 'b', 4]
# 将第3个到第6个（不包含）元素赋值为空列表，就是删除
b_list[2: 5] = []
print(b_list) # [1, 'a', 4]
# Python会自动将str分解成序列
b_list[1: 3] = 'Charlie'
print(b_list) # [1, 'C', 'h', 'a', 'r', 'l', 'i', 'e']
c_list = list(range(1, 10))
# 指定step为2，被赋值的元素有4个，因此用于赋值的列表也必须有4个元素
c_list[2: 9: 2] = ['a', 'b', 'c', 'd']
print(c_list) # [1, 2, 'a', 4, 'b', 6, 'c', 8, 'd']
列表的其他常用方法
# count() 列表中某个元素出现的次数
a_list = [2, 30, 'a', [5, 30], 30]
# 计算列表中30的出现次数
print(a_list.count(30)) # 2
# 计算列表中[5, 30]的出现次数
print(a_list.count([5, 30])) # 1
# index() 定位列表元素 可传入start、end参数，用于指定搜索范围
a_list = [2, 30, 'a', 'b', 'crazyit', 30]
# 定位元素30的出现位置
print(a_list.index(30)) # 1
# 从索引2处开始、定位元素30的出现位置
print(a_list.index(30, 2)) # 5
# 从索引2处到索引4处之间定位元素30的出现位置，找不到该元素
print(a_list.index(30, 2, 4)) # ValueError
# pop() 方法用于实现元素出栈功能，返回删除的元素内容
# append() 方法可用于入栈操作
# 栈是一种特殊的数据结构，它可实现先入后出（FILO ）功 能，即先加入栈的元素，反而后出栈。
stack = []
# 向栈中“入栈”3个元素
stack.append("fkit")
stack.append("crazyit")
stack.append("Charlie")
print(stack) # ['fkit', 'crazyit', 'Charlie']
# 第一次出栈：最后入栈的元素被移出栈
print(stack.pop())
print(stack) # ['fkit', 'crazyit']
# 再次出栈
print(stack.pop())
print(stack) # ['fkit']
# reverse() 元素反转
a_list = list(range(1, 8))
# 将a_list列表元素反转
a_list.reverse()
print(a_list) # [7, 6, 5, 4, 3, 2, 1]
# sort() 方法对列表元素排序
a_list = [3, 4, -2, -30, 14, 9.3, 3.4]
# 对列表元素排序
a_list.sort()
print(a_list) #[-30, -2, 3, 3.4, 4, 9.3, 14]
b_list = ['Python', 'Swift', 'Ruby', 'Go', 'Kotlin', 'Erlang']
# 对列表元素排序：默认按字符串包含的字符的编码大小比较
b_list.sort()
print(b_list) # ['Erlang', 'Go', 'Kotlin', 'Python', 'Ruby', 'Swift']
# 指定key为len，指定使用len函数对集合元素生成比较的键，
# 也就是按字符串的长度比较大小
b_list.sort(key=len)
print(b_list) # ['Go', 'Ruby', 'Swift', 'Erlang', 'Kotlin', 'Python']
# 指定反向排序
b_list.sort(key=len, reverse=True)
print(b_list) # ['Erlang', 'Kotlin', 'Python', 'Swift', 'Ruby', 'Go']
# 以下代码只能在Python 2.x中执行
# 定义一个根据长度比较大小的比较函数
def len_cmp(x, y):
# 下面代码比较大小的逻辑是：长度大的字符串就算更大
return 1 if len(x) > len(y) else (-1 if len(x) < len(y) else 0)
b_list.sort(len_cmp)
print(b_list) #['Go', 'Ruby', 'Swift', 'Erlang', 'Kotlin', 'Python']
字典的使用
创建字典
花括号中应该包含多个key-value对，之间用逗号（，）隔开，key与value之间用冒号（：）隔开
# 使用{}创建字典
scores = {'语文': 89, '数学': 92, '英语': 93}
print(scores)
# 空的花括号代表空的dict
empty_dict = {}
print(empty_dict)
# 使用元组作为dict的key
dict2 = {(20, 30):'good', 30:'bad'}
print(dict2)
# 使用dict() 创建字典，可传入多个元组或列表作为key-value对
# 每个元组或列表被当成一个键值对，因此，列表或元组只能包含两个元素
# 元组可以做 dict 的 key，列表不行，dict 要求key不可变
vegetables = [('celery', 1.58), ('brocoli', 1.29), ('lettuce', 2.19)]
# 创建包含3组key-value对的字典
dict3 = dict(vegetables)
print(dict3) # {'celery': 1.58, 'brocoli': 1.29, 'lettuce': 2.19}
cars = [['BMW', 8.5], ['BENS', 8.3], ['AUDI', 7.9]]
# 创建包含3组key-value对的字典
dict4 = dict(cars)
print(dict4) # {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
# 创建空的字典
dict5 = dict()
print(dict5) # {}
# 可通过为 dict()指定关键字参数创建字典，此时字典的 key不允许使用表达式
dict6 = dict(spinach = 1.39, cabbage = 2.59)
print(dict6) # {'spinach': 1.39, 'cabbage': 2.59}
字典的基本用法
scores = {'语文': 89}
# 通过key访问value
print(scores['语文'])
# 对不存在的key赋值，就是增加key-value对
scores['数学'] = 93
scores[92] = 5.7
print(scores) # {'语文': 89, '数学': 93, 92: 5.7}
# 使用del语句删除key-value对
del scores['语文']
del scores['数学']
print(scores) # {92: 5.7}
cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
# 对存在的key-value对赋值，改变key-value对
cars['BENS'] = 4.3
cars['AUDI'] = 3.8
print(cars) # {'BMW': 8.5, 'BENS': 4.3, 'AUDI': 3.8}
# 判断cars是否包含名为'AUDI'的key
print('AUDI' in cars) # True
# 判断cars是否包含名为'PORSCHE'的key
print('PORSCHE' in cars) # False
print('LAMBORGHINI' not in cars) # True
字典的常用方法
cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
print(cars) # {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
# clear() 清空cars所有key-value对
cars.clear()
print(cars) # {}
# cars.get('BMW') 获取'BMW'对应的value,如果不存在，返回None
# cars['BMW'] 获取value时，如果不存在引发KeyError错误
print(cars.get('BMW')) # 8.5
print(cars.get('PORSCHE')) # None
print(cars['PORSCHE']) # KeyError
# cars.update() 更新指定键的值，如果字典中不存在指定的键，该键值对会被添加进去
cars.update({'BMW':4.5, 'PORSCHE': 9.3})
print(cars)
# cars.items() 获取字典所有的key-value对，返回一个dict_items对象
ims = cars.items()
print(type(ims)) # 使用字典格式化字符串
# 字符串模板中使用key
temp = '书名是:%(name)s, 价格是:%(price)010.2f, 出版社是:%(publish)s'
book = {'name':'疯狂Python讲义', 'price': 88.9, 'publish': '电子社'}
# 使用字典为字符串模板中的key传入值
print(temp % book)
流程控制
if
# 1
if expression:
statements ...
# 2.
if expression:
statements...
else:
statements...
s_age = input("请输入您的年龄:")
age = int(s_age)
if age > 20 :
# 只有当age > 20时，下面用整体缩进的代码块才会执行
# 整体缩进的语句是一个整体，要么一起执行，要么一起不执行
print("年龄已经大于20岁了")
print("20岁以上的人应该学会承担责任...")
if表达式
pass语句
s = input("请输入一个整数: ")
s = int(s)
if s > 5:
print("大于5")
elif s < 5:
# 空语句，相当于占位符
pass
else:
print("等于5")
断言
s_age = input("请输入您的年龄:")
age = int(s_age)
assert 20 < age < 80
print("您输入的年龄在20和80之间")
循环结构
while循环
[init_statements]
while test_expression:
body_statements
[iteration_atatements]
# 循环的初始化条件
count_i = 0
# 当count_i小于10时，执行循环体
while count_i < 10 :
print("count:", count_i)
# 迭代语句
count_i += 1
print("循环结束!")
# 下面是一个死循环
count_i2 = 0
while count_i2 < 10 :
print("不停执行的死循环:", count_i2)
count_i2 -=1
print("永远无法跳出的循环体")
# while循环遍历元组
a_tuple = ('fkit', 'crazyit', 'Charli')
i = 0
# 只有i小于len(a_list)，继续执行循环体
while i < len(a_tuple):
print(a_tuple[i]) # 根据i来访问元组的元素
i += 1
# while循环遍历列表
src_list = [12, 45, 34,13, 100, 24, 56, 74, 109]
a_list = [] # 定义保存整除3的元素
b_list = [] # 定义保存除以3余1的元素
c_list = [] # 定义保存除以3余2的元素
# 只要src_list还有元素，继续执行循环体
while len(src_list) > 0:
# 弹出src_list最后一个元素
ele = src_list.pop()
# 如果ele % 2不等于0
if ele % 3 == 0 :
a_list.append(ele) # 添加元素
elif ele % 3 == 1:
b_list.append(ele) # 添加元素
else:
c_list.append(ele) # 添加元素
print("整除3:", a_list)
print("除以3余1:",b_list)
print("除以3余2:",c_list)
for-in 循环
for-in 循环的语法格式：for 变量 in 字符串|范围|集合等：
statements
# 使用 for-in 循环来计算指定整数的阶乘
s_max = input("请输入您想计算的阶乘:")
mx = int(s_max)
result = 1
# 使用for-in循环遍历范围
for num in range(1, mx + 1):
result *= num
print(result)
for-in 循环遍历列表和元组
# for-in 循环遍历元组
a_tuple = ('crazyit', 'fkit', 'Charlie')
for ele in a_tuple:
print('当前元素是:', ele)
# for-in循环遍历列表
src_list = [12, 45, 3.4, 13, 'a', 4, 56, 'crazyit', 109.5]
my_sum = 0
my_count = 0
for ele in src_list:
# 如果该元素是整数或浮点数
if isinstance(ele, int) or
# isinstance() 函数判断变量是否为制定类型
isinstance(ele, float):
print(ele)
# 累加该元素
my_sum += ele
# 数值元素的个数加1
my_count += 1
print('总和:', my_sum)
print('平均数:', my_sum / my_count)
# for-in 循环通过索引来遍历列表
a_list = [330, 1.4, 50, 'fkit', -3.5]
# 遍历0到len(a_list)的范围
for i in range(0, len(a_list)) :
# 根据索引访问列表元素
print("第%d个元素是 %s" % (i , a_list[i]))
for-in 遍历字典
my_dict = {'语文': 89, '数学': 92, '英语': 80}
# 通过items()方法遍历所有key-value对
# 由于items方法返回的列表元素是key-value对，因此要声明两个变量
for key, value in my_dict.items():
print('key:', key)
print('value:', value)
print('-------------')
# 通过keys()方法遍历所有key
for key in my_dict.keys():
print('key:', key)
# 在通过key获取value
print('value:', my_dict[key])
print('-------------')
# 通过values()方法遍历所有value
for value in my_dict.values():
print('value:', value)
# 统计列表中个元素出现的次数
src_list = [12, 45, 3.4, 12, 'fkit', 45, 3.4, 'fkit', 45, 3.4]
statistics = {}
for ele in src_list:
# 如果字典中包含ele代表的key
if ele in statistics:
# 将ele元素代表出现次数加1
statistics[ele] += 1
# 如果字典中不包含ele代表的key，说明该元素还未出现国
else:
# 将ele元素代表出现次数设为1
statistics[ele] = 1
# 遍历dict，打印出各元素的出现次数
for ele, count in statistics.items():
print("%s的出现次数为:%d" % (ele, count))
循环使用 else
# while 循环使用else
count_i = 0
while count_i < 5:
print('count_i小于5: ', count_i)
count_i += 1
else:
print('count_i大于或等于5: ', count_i)
# for 循环使用else
a_list = [330, 1.4, 50, 'fkit', -3.5]
for ele in a_list:
print('元素: ', ele)
else:
# 访问循环计数器的值，依然等于最后一个元素的值
print('else块: ', ele)
嵌套循环
# 外层循环
for i in range(0, 5) :
j = 0
# 内层循环
while j < 3 :
print("i的值为: %d , j的值为: %d" % (i, j))
j += 1
for 表达式
for表达式的语法如下:
a_range = range(10)
# 对a_range执行for表达式
a_list = [x * x for x in a_range]
# a_list集合包含10个元素
print(a_list)
b_list = [x * x for x in a_range if x % 2 == 0]
# b_list集合包含5个元素
print(b_list)
# 使用for表达式创建生成器
c_generator = (x * x for x in a_range if x % 2 == 0)
# 使用for循环迭代生成器
for i in c_generator:
print(i, end='\t')
print()
d_list = [(x, y) for x in range(5) for y in range(4)]
# d_list列表包含20个元素
print(d_list)
dd_list = []
for x in range(5):
for y in range(4):
dd_list.append((x, y))
print(dd_list)
e_list = [[x, y, z] for x in range(5) for y in range(4) for z in range(6)]
# 3_list列表包含120个元素
print(e_list)
src_a = [30, 12, 66, 34, 39, 78, 36, 57, 121]
src_b = [3, 5, 7, 11]
# 只要y能整除x，就将它们配对在一起
result = [(x, y) for x in src_b for y in src_a if y % x == 0]
print(result)
常用工具函数
zip()
books = ['Kotlin讲义', 'Swift讲义', 'Python讲义']
prices = [79, 69, 89]
# 使用zip()函数压缩两个列表，从而实现并行遍历
for book, price in zip(books, prices):
print("%s的价格是: %5.2f" % (book, price))
reversed()
sorted()
对参数本身不会产生影响my_list = ['fkit', 'crazyit', 'Charlie', 'fox', 'Emily']
# 通过传入key参数，指定一个函数来生产排序的关键值
# key=len 按字符串长度排序
for s in sorted(my_list, key=len):
print(s)
# 通过设置reverse参数，可反向排序
print(sorted(my_list, reverse=True))
控制循环结构
break结束循环
对于嵌套循环，break只能结束所在的循环#
# break 跳出循环
exit_flag = False
# 外层循环
for i in range(0, 5) :
# 内层循环
for j in range(0, 3 ) :
print("i的值为: %d, j的值为: %d" % (i, j))
if j == 1 :
exit_flag = True
# 跳出里层循环
break
# 如果exit_flag为True，跳出外层循环
if exit_flag :
break
# for else 语句
for i in range(0, 10) :
print("i的值是: ", i)
if i == 2 :
# 执行该语句时将结束循环，不执行else语句
break
else:
print('else块: ', i)
continue 忽略本次循环的剩下语句
for i in range(0, 3 ) :
print("i的值是: ", i)
if i == 1 :
# 忽略本次循环的剩下语句
continue
print("continue后的输出语句")
return 结束方法
def test() :
# 外层循环
for i in range(10) :
for j in range(10) :
print("i的值是: %d, j的值是: %d" % (i , j))
if j == 1 :
return
print("return后的输出语句")
test()
函数和lambda表达式
函数入门
定义函数和调用函数
def 函数名（形参列表）：
//由零到多条可执行语句组成的函数
[return [返回值]]
## 定义一个函数，声明2个形参
#def my_max(x, y) :
# # 定义一个变量z，该变量等于x、y中较大的值
# z = x if x > y else y
# # 返回变量z的值
# return z
def my_max(x, y) :
# 返回一个表达式
return x if x > y else y
# 定义一个函数，声明一个形参
def say_hi(name) :
print("===正在执行say_hi()函数===")
return name + "，您好！"
a = 6
b = 9
# 调用my_max()函数，将函数返回值赋值给result变量
result = my_max(a , b) #
print("result:", result)
# 调用say_hi()函数，直接输出函数的返回值
print(say_hi("孙悟空")) #
为函数提供文档
def my_max(x, y) :
'''
获取两个数值之间较大数的函数。
my_max(x, y)
返回x、y两个参数之间较大的那个
'''
# 定义一个变量z，该变量等于x、y中较大的值
z = x if x > y else y
# 返回变量z的值
return z
# 使用help()函数查看my_max的帮助文档
help(my_max)
print(my_max.__doc__)
返回多个值
def sum_and_avg(list):
sum = 0
count = 0
for e in list:
# 如果元素e是数值
if isinstance(e, int) or isinstance(e, float):
count += 1
sum += e
return sum, sum / count
my_list = [20, 15, 2.8, 'a', 35, 5.9, -1.8]
# 获取sum_and_avg函数返回的多个值，多个返回值被封装成元组
tp = sum_and_avg(my_list) #①
print(tp)
# 使用序列解包来获取多个返回值
s, avg = sum_and_avg(my_list) #②
print(s)
print(avg)
递归函数
def fn(n) :
if n == 0 :
return 1
elif n == 1 :
return 4
else :
# 函数中调用它自身，就是函数递归
return 2 * fn(n - 1) + fn(n - 2)
# 输出fn(10)的结果
print("fn(10)的结果是:", fn(10))
函数的参数
# 定义一个函数
def girth(width , height):
print("width: ", width)
print("height: ", height)
return 2 * (width + height)
# 传统调用函数的方式，根据位置传入参数
print(girth(3.5, 4.8))
# 根据关键字参数来传入参数
print(girth(width = 3.5, height = 4.8))
# 使用关键字参数时可交换位置
print(girth(height = 4.8, width = 3.5))
# 部分使用关键字参数，部分使用位置参数
print(girth(3.5, height = 4.8))
# 位置参数必须放在关键字参数之前，下面代码错误
print(girth(width = 3.5, 4.8))
# 为两个参数指定默认值
def say_hi(name = "孙悟空", message = "欢迎来到疯狂软件"):
print(name, ", 您好")
print("消息是：", message)
# 全部使用默认参数
say_hi()
# 只有message参数使用默认值
say_hi("白骨精")
# 两个参数都不使用默认值
say_hi("白骨精", "欢迎学习Python")
# 只有name参数使用默认值
say_hi(message = "欢迎学习Python")
say_hi("欢迎学习Python")
#say_hi(name="白骨精", "欢迎学习Python")
#say_hi("欢迎学习Python" , name="白骨精")
say_hi("白骨精", message="欢迎学习Python")
say_hi(name="白骨精", message="欢迎学习Python")
# 定义一个打印三角形的函数，有默认值的参数必须放在后面
def printTriangle(char, height = 5) :
for i in range(1, height + 1) :
# 先打印一排空格
for j in range(height - i) :
print(' ', end = '')
# 再打印一排特殊字符
for j in range(2 * i - 1) :
print(char, end = '')
print()
printTriangle('@', 6)
printTriangle('#', height=7)
printTriangle(char = '*')
# 定义了支持参数收集的函数
def test(a, *books) :
print(books)
# books被当成元组处理
for b in books :
print(b)
# 输出整数变量a的值
print(a)
# 调用test()函数
test(5 , "疯狂iOS讲义" , "疯狂Android讲义")
# 定义了支持参数收集的函数
def test(*books ,num) :
print(books)
# books被当成元组处理
for b in books :
print(b)
print(num)
# 调用test()函数
test("疯狂iOS讲义", "疯狂Android讲义", num = 20)
my_list = ["疯狂Swift讲义", "疯狂Python讲义"]
# 将列表的多个元素传给支持参数收集的参数
test(my_list, num = 20)
my_tuple= ("疯狂Swift讲义", "疯狂Python讲义")
# 将元组的多个元素传给支持参数收集的参数
test(*my_tuple, num = 20)
# 定义了支持参数收集的函数
def test(x, y, z=3, *books, **scores) :
print(x, y, z)
print(books)
print(scores)
test(1, 2, 3, "疯狂iOS讲义" , "疯狂Android讲义", 语文=89, 数学=94)
test(1, 2, "疯狂iOS讲义" , "疯狂Android讲义", 语文=89, 数学=94)
test(1, 2, 语文=89, 数学=94)
# 逆向收集参数
def test(name, message):
print("用户是: ", name)
print("欢迎消息: ", message)
my_list = ['孙悟空', '欢迎来疯狂软件']
test(*my_list)
def foo(name, *nums):
print("name参数: ", name)
print("nums参数: ", nums)
my_tuple = (1, 2, 3)
# 使用逆向收集，将my_tuple元组的元素传给nums参数
foo('fkit', *my_tuple)
# 使用逆向收集，将my_tuple元组的第一个元素传给name参数，剩下参数传给nums参数
foo(*my_tuple)
# 不使用逆向收集，my_tuple元组整体传给name参数
foo(my_tuple)
def bar(book, price, desc):
print(book, " 这本书的价格是: ", price)
print('描述信息', desc)
my_dict = {'price': 89, 'book': '疯狂Python讲义', 'desc': '这是一本系统全面的Python学习图书'}
# 按逆向收集的方式将my_dict的多个key-value传给bar()函数
bar(**my_dict)
变量的作用域
def test ():
age = 20
# 直接访问age局部变量
print(age) # 输出20
# 访问函数局部范围的“变量数组”
print(locals()) # {'age': 20}
# 通过函数局部范围的“变量数组”访问age变量
print(locals()['age']) # 20
# 通过locals函数局部范围的“变量数组”改变age变量的值
locals()['age'] = 12
# 再次访问age变量的值
print('xxx', age) # 依然输出20
# 通过globals函数修改x全局变量
globals()['x'] = 19
x = 5
y = 20
print(globals()) # {..., 'x': 5, 'y': 20}
# 在全局访问内使用locals函数，访问的是全局变量的“变量数组”
print(locals()) # {..., 'x': 5, 'y': 20}
# 直接访问x全局变量
print(x) # 5
# 通过全局变量的“变量数组”访问x全局变量
print(globals()['x']) # 5
# 通过全局变量的“变量数组”对x全局变量赋值
globals()['x'] = 39
print(x) # 输出39
# 在全局范围内使用locals函数对x全局变量赋值
locals()['x'] = 99
print(x) # 输出99
name = 'Charlie'
def test ():
# 直接访问name全局变量
print(name) # Charlie
name = '孙悟空'
test()
print(name)
name = 'Charlie'
def test ():
# 直接访问name全局变量
print(globals()['name']) # Charlie
name = '孙悟空'
test()
print(name) # Charlie
name = 'Charlie'
def test ():
# 声明name是全局变量，后面的赋值语句不会重新定义局部变量
global name
# 直接访问name全局变量
print(name) # Charlie
name = '孙悟空'
test()
print(name) # 孙悟空
局部函数
局部函数：在函数体内定义的函数# 定义函数，该函数会包含局部函数
vdef get_math_func(type, nn) :
# 定义一个计算平方的局部函数
def square(n) : # ①
return n * n
# 定义一个计算立方的局部函数
def cube(n) : # ②
return n * n * n
# 定义一个计算阶乘的局部函数
def factorial(n) : # ③
result = 1
for index in range(2, n + 1) :
result *= index
return result
# 调用局部函数
if type == "square" :
return square(nn)
elif type == "cube":
return cube(nn)
else:
return factorial(nn)
print(get_math_func("square", 3)) # 输出9
print(get_math_func("cube", 3)) # 输出27
print(get_math_func("", 3)) # 输出6
def foo ():
# 局部变量name
name = 'Charlie'
def bar ():
nonlocal name
# 访问bar函数所在的foo函数的name局部变量
print(name) # Charlie
name = '孙悟空'
bar()
foo()
函数的高级内容
使用函数变量
# 定义一个计算乘方的函数
def pow(base, exponent) :
result = 1
for i in range(1, exponent + 1) :
result *= base
return result
# 将pow函数赋值给my_fun，则my_fun可当成pow使用
my_fun = pow
print(my_fun(3 , 4)) # 输出81
# 定义一个计算面积的函数
def area(width, height) :
return width * height
# 将area函数赋值给my_fun，则my_fun可当成area使用
my_fun = area
print(my_fun(3, 4)) # 输出12
函数作为函数形参
# 定义函数类型的形参，其中fn是一个函数
def map(data, fn) :
result = []
# 遍历data列表中每个元素，并用fn函数对每个元素进行计算
# 然后将计算结果作为新数组的元素
for e in data :
result.append(fn(e))
return result
# 定义一个计算平方的函数
def square(n) :
return n * n
# 定义一个计算立方的函数
def cube(n) :
return n * n * n
# 定义一个计算阶乘的函数
def factorial(n) :
result = 1
for index in range(2, n + 1) :
result *= index
return result
data = [3 , 4 , 9 , 5, 8]
print("原数据: ", data)
# 下面程序代码3次调用map()函数，每次调用时传入不同的函数
print("计算数组元素的平方")
print(map(data , square))
print("计算数组元素的立方")
print(map(data , cube))
print("计算数组元素的阶乘")
print(map(data , factorial))
# 获取map的类型
print(type(map))
函数作为返回值
def get_math_func(type) :
# 定义一个计算平方的局部函数
def square(n) : # ①
return n * n
# 定义一个计算立方的局部函数
def cube(n) : # ②
return n * n * n
# 定义一个计算阶乘的局部函数
def factorial(n) : # ③
result = 1
for index in range(2 , n + 1):
result *= index
return result
# 返回局部函数
if type == "square" :
return square
if type == "cube" :
return cube
else:
return factorial
# 调用get_math_func()，程序返回一个嵌套函数
math_func = get_math_func("cube") # 得到cube函数
print(math_func(5)) # 输出125
math_func = get_math_func("square") # 得到square函数
print(math_func(5)) # 输出25
math_func = get_math_func("other") # 得到factorial函数
print(math_func(5)) # 输出120
lambda表达式
lambda [parameter_list]: 表达式
def get_math_func(type) :
result=1
# 该函数返回的是Lambda表达式
if type == 'square':
return lambda n: n * n # ①
elif type == 'cube':
return lambda n: n * n * n # ②
else:
return lambda n: (1 + n) * n / 2 # ③
# 调用get_math_func()，程序返回一个嵌套函数
math_func = get_math_func("cube")
print(math_func(5)) # 输出125
math_func = get_math_func("square")
print(math_func(5)) # 输出25
math_func = get_math_func("other")
print(math_func(5)) # 输出15.0
a = lambda x, y: x + y
def add(x, y): return x+ y
# 传入计算平方的lambda表达式作为参数
x = map(lambda x: x*x , range(8))
print([e for e in x]) # [0, 1, 4, 9, 16, 25, 36, 49]
# 传入计算平方的lambda表达式作为参数
y = map(lambda x: x*x if x % 2 == 0 else 0, range(8))
print([e for e in y]) # [0, 0, 4, 0, 16, 0, 36, 0]